(only non hidden objects are presented)
| COM | tmp | [( [{[Dn: minus.1 = Dn: squash_df.1 = Dn: not_df.1 = Dn: NOT_df.1]} | Dn: list.1] > [(Dn: apply.1 > [([Dn: div.1 | Dn: mul.1 | Dn: rem.1] > [Dn: sub.1 | Dn: add.1]) | ([Dn: function.1 | Dn: product.1] > Dn: union.1)]) | Dn: infix_ap_df.1] > ( {[Dn: equal.1 = Dn: lt.1 = Dn: member_df.1 = Dn: eqi.1 = Dn: le_df.1 = Dn: ge_df.1 = Dn: gt_df.1]} > [Dn: and_df.1 | Dn: or_df.1] > [Dn: iff_df.1 | Dn: implies_df.1 | Dn: rev_implies_df.1] ) > {[Dn: lambda.1 = Dn: exists_df.1 = Dn: all_df.1]} ) | Dn: inr.1 | Dn: inl.1 | Dn: sq_exists_df.1 | Dn: pi1_df.1 | Dn: pi2_df.1] |
| ML | BogusRule | let BogusRule = Refine `because` [];; |
| DISP | cons_df2 | Parens ::Index 0 :: {[SOFT}<h:term>{\\}::<t:list:E>{]}== <h>::<t> |
| THM | nat_inc | |
| THM | int_wf1 | |
| THM | subtract_wf_nat | |
| THM | decidable__intlist_equality | |
| ABS | xor | p |
| THM | xor_wf | |
| DISP | xor_df |
RAssoc Infix Display Form Generator
Prec: xor
Slot Name: prop
Infix Chars: " |
| ABS | exists_unique | |
| THM | exists_unique_wf | |
| DISP | exists_unique_df | Parens ::Prec(exists)::
|
| THM | atom_wf1 | Atom |
| DISP | atom_eq_pred_df | atom_eq_pred()== atom_eq_pred() |
| ABS | atom_eq_pred | atom_eq_pred() == |
| THM | atom_eq_pred_wf | atom_eq_pred() |
| DISP | decidable_true_df | true(<P:P:*>)== true(<P>) |
| ABS | decidable_true | true(P) == isl(d) |
| THM | decidable_true_wf | |
| THM | assert_of_decidable_true | |
| ML | decidable_true_simp | simpset_add `HOL_standard_lib_simps` (lemma_simp `assert_of_decidable_ true`) ;; |
| THM | list_char | |
| DISP | list_el_df | list_el(<A:A:*><x:x:*><l:l:*>)== list_el(<A><x><l>) |
| ML | list_el_ml | list_el(A;x;l)
==r if null(l) then False else x = hd(l) |
| THM | list_el_wf | |
| THM | list_el_nil | |
| THM | list_el_cons | |
| THM | list_el_snoc | |
| ML | list_el_simps | simpset_add `HOL_standard_lib_simps` (lemma_simp `list_el_nil`) ;; simpset_add `HOL_standard_lib_simps` (lemma_simp `list_el_cons`) ;; simpset_add `HOL_standard_lib_simps` (lemma_simp `list_el_snoc`) ;; |
| THM | list_el_mono | |
| THM | list_el_map | |
| DISP | listsubset_df | listsubset(<A:A:*><l1:l1:*><l2:l2:*>)== listsubset(<A><l1><l2>) |
| ABS | listsubset | listsubset(A;l1;l2) == |
| THM | listsubset_wf | |
| ML | listsubset_simp | simpset_add `HOL_standard_lib_simps` (unfold_top_simp `listsubset`) ;; |
| THM | filter_listsubset | |
| THM | snoc_listsubset | |
| THM | but_last_el_listsubset | |
| THM | firstn_listsubset | |
| THM | lastn_listsubset | |
| THM | seg_not_null | |
| THM | last_el_nil | |
| THM | last_el_cons | |
| THM | but_last_el_nil | |
| THM | but_last_el_cons | |
| THM | last_el_list_el | |
| THM | last_or_butlast | |
| THM | but_last_el_last_append | |
| THM | length_filter_but_last_el_ff | |
| THM | mt_filter_ff | |
| THM | list_el_filter_tt | |
| THM | list_el_filter_tt_iff | |
| THM | length_filter | |
| THM | length_1_filter | |
| THM | length_2_filter | |
| THM | el_length_1_filter | |
| THM | last_butlast_length_2_filter | |
| THM | mt_snoc | |
| THM | map_null | |
| THM | last_el_map | |
| THM | but_last_el_map | |
| THM | length_but_last_el | |
| THM | el_but_last_el | |
| THM | distrib_el_append | |
| THM | last_el_select | |
| THM | but_last_el_firstn | |
| THM | list_el_firstn_but_last_el | |
| THM | list_el_lastn_but_last_el | |
| THM | list_el_select | |
| THM | filter1_firstn_ff | |
| THM | filter1_lastn_ff | |
| ML | hol1_simpset | map (simpset_add `hol1`) (get_simpset `HOL_standard_lib_simps`) ;; map ((simpset_add `hol1`) o lemma_simp) ``last_el_nil last_el_cons but_last_el_nil but_last_el_cons mt_snoc map_null last_el_map but_last_el_map el_but_last_el length_but_last_el distrib_el_append`` ;; map ((simpset_add `hol1`) o rev_lemma_simp) ``last_el_select but_last_el_firstn`` ;; |
| COM | sci_base_1 | ---- Booleans ------------------------------------------- |
| ABS | zbool | o == {k: |
| DISP | zbool_df | o== o |
| THM | zbool_wf | o |
| ML | zbool_ml_inc | add_set_inclusion_info `zbool` `int` AbSetDForInc Auto;; |
| THM | zbool_inc | o |
| ABS | ztrue | true == 1 |
| DISP | ztrue_df | true== true |
| THM | ztrue_wf | true |
| ABS | zfalse | false == 0 |
| DISP | zfalse_df | false== false |
| THM | zfalse_wf | false |
| THM | zbool_char | |
| ABS | truez | [b] == b = true |
| DISP | truez_df | [<b:zbool>]== [<b>] |
| THM | truez_wf | |
| THM | truez_false | |
| THM | truez_true | |
| ML | truez_simps | add_to_simpset `zbool_iff_simps` (lemma_to_simp `truez_false`) ;; add_to_simpset `zbool_iff_simps` (lemma_to_simp `truez_true`) ;; |
| ABS | zand | A |
| DISP | zand_df |
RAssoc Infix Display Form Generator
Prec: and
Slot Name: zbool
Infix Chars: " |
| THM | zand_wf | |
| THM | truez_and | |
| ML | zand_simp | add_to_simpset `zbool_iff_simps` (lemma_to_simp `truez_and`) ;; |
| ABS | znot | |
| DISP | znot_df | Parens ::Prec(preop):: |
| THM | znot_wf | |
| THM | truez_not | |
| ML | znot_simp | add_to_simpset `zbool_iff_simps` (lemma_to_simp `truez_not`) ;; |
| ABS | zor | A |
| DISP | zor_df |
RAssoc Infix Display Form Generator
Prec: or
Slot Name: zbool
Infix Chars: " |
| THM | zor_wf | |
| THM | truez_or | |
| ML | zor_simp | add_to_simpset `zbool_iff_simps` (lemma_to_simp `truez_or`) ;; |
| ABS | zif | if b then x else y == if b=1 then x else y |
| DISP | zif_df | if <b:zbool> then <s:Term:*> else <t:Term:E> == if <b> then <s> else <t> |
| THM | zif_wf | |
| THM | zif_char | |
| ML | zif_char_simps | map (add_to_simpset `zbool_simps`) (lemma_clauses_to_simps `zif_char`) ;; |
| ABS | z_int_eq | n1 = n2 == if n1=n2 then true else false |
| DISP | z_int_eq_df | Parens ::Prec(atomrel)::Index 0 :: {[SOFT}<t1:int:L>{\\ }= {->0}<t2:int:L>{<-}{]} == <t1> = <t2> |
| THM | z_int_eq_wf | |
| THM | z_int_eq_rw | |
| ML | z_int_eq_rw_simp | add_to_simpset `zbool_simps` (lemma_to_simp `z_int_eq_rw`) ;; |
| THM | z_int_neq_rw | |
| THM | truez_int_eq | |
| ML | z_int_eq_simp | add_to_simpset `zbool_iff_simps` (lemma_to_simp `truez_int_eq`) ;; |
| ABS | z_atom_eq | n1 = n2 == if n1=n2 then true else false |
| DISP | z_atom_eq_df | Parens ::Prec(atomrel)::Index 0 :: {[SOFT}<t1:atom:L>{\\ }= {->0}<t2:atom:L>{<-}{]} == <t1> = <t2> |
| THM | z_atom_eq_wf | |
| THM | z_atom_eq_rw | |
| ML | z_atom_eq_rw_simp | add_to_simpset `zbool_simps` (lemma_to_simp `z_atom_eq_rw`) ;; |
| THM | z_atom_neq_rw | |
| THM | truez_atom_eq | |
| ML | z_atom_eq_simp | add_to_simpset `zbool_iff_simps` (lemma_to_simp `truez_atom_eq`) ;; |
| DISP | znull_df | znull(<l:l:*>)== znull(<l>) |
| ABS | znull | znull(l) == case l of [] => true | a::l' => false esac |
| THM | znull_wf | |
| THM | truez_null | |
| THM | znull_nil | znull([]) = true |
| THM | znull_cons | |
| ML | znull_cons_simp | add_to_simpset `zbool_simps` (lemma_to_simp `znull_cons`) ;; |
| ML | zbool_iff_simpset1 | map ((simpset_add `zbool_iff`) o lemma_simp) ``truez_false truez_true truez_and truez_not truez_or truez_int_eq truez_atom_eq truez_null`` ;; |
| ML | zbool_simpset1 | map (simpset_add `zbool`) (lemma_simps `zif_char`) ;; map ((simpset_add `zbool`) o lemma_simp) ``z_int_eq_rw z_atom_eq_rw znull_nil znull_cons`` ;; |
| COM | sci_base_2 | ---- Basic Types ----------------------------------------- |
| ABS | pid | PId == {k: |
| ABS | pids | PId? == {k: |
| ABS | vproc | P(N) == {p:PId| 1 |
| ABS | vpid | P+m(N) == {p:PId| p |
| ABS | vpids | P?(N) == {p:PId?| p |
| DISP | pid_df | PId== PId |
| DISP | pids_df | PId?== PId? |
| DISP | vproc_df | P(<n:nat>)== P(<n>) P== P |
| DISP | vpid_df | P+m(<n:nat>)== P+m(<n>) P+m== P+m |
| DISP | vpids_df | P?(<n:nat>)== P?(<n>) P?== P? |
| THM | pid_wf | PId |
| THM | pid_wf1 | PId |
| THM | pids_wf | PId? |
| THM | vproc_wf | |
| THM | vpid_wf | |
| THM | vpids_wf | |
| THM | pid_inc | PId |
| THM | pid_int_inc | PId |
| THM | pids_inc | PId? |
| THM | vproc_inc | |
| THM | vpid_inc | |
| THM | vproc_pids_inc | |
| THM | vproc_pid_inc | |
| THM | vpid_pid_inc | |
| THM | vpids_inc | |
| THM | vpid_pids_inc | |
| COM | inclusion_comment | -- ml_inc's below are what is used by the autotactic (see Sect. 10.2.5 of the manual), the inc lemmas above don't seem to be needed |
| ML | pids_int_ml_inc | add_set_inclusion_info `pids` `int` AbSetDForInc Auto;; |
| ML | pid_pids_ml_inc | add_set_inclusion_info `pid` `pids` AbSetDForInc Auto;; |
| ML | vpids_pids_ml_inc | add_set_inclusion_info `vpids` `pids` AbSetDForInc Auto;; |
| ML | vpid_pid_ml_inc | add_set_inclusion_info `vpid` `pid` AbSetDForInc Auto;; |
| ML | vproc_vpid_ml_inc | add_set_inclusion_info `vproc` `vpid` AbSetDForInc Auto;; |
| ML | pid_arith_types | arith_types := union ``vpid vproc pid pids`` arith_types ;; |
| THM | subtype_dec | |
| THM | decidable__pid_equality | |
| THM | decidable__pids_equality | |
| THM | decidable__vproc_equality | |
| THM | decidable__vpid_equality | |
| THM | pid_eq | |
| ML | pid_eq_ml | let PidEq p = (let g = (concl p) in if ((is_equal_term g) & (is_term ` pid` (fst (dest_equal g)))) then (BLemma `pid_eq` THENM Trivia l) else Fail) p ;; update_Auto_additions `PidEq` PidEq ;; |
| DISP | id_df | id== id |
| ABS | id | id == Atom |
| THM | id_wf | id |
| DISP | id_tup_df | <a:a:*><p:p:*>== <a><p> |
| ABS | id_tup | ap == <a, p> |
| THM | id_tup_wf | |
| DISP | mk_id_df | EdAlias mk_id :: <x:string>-<n:nat>== <x>-<n> <x:string>-== <x>- |
| ABS | mk_id | $s-i == "$s"i |
| ML | mk_id_inf_ml | add_type_inf_fun `mk_id` (\g e t. mk_simple_term `id` []) ;; |
| ML | mk_id_eq_ml | update_EqCD_additions `mk_id` (\p. if opid_of_term (first_equand (concl p)) = `mk_id` then Unfolds ``mk_id`` 0 p else fail);; |
| ABS | id_name | id.name == id.1 |
| THM | id_name_wf | |
| DISP | id_name_df | Parens ::Prec(pi1):: <t:id:*>.name== <t>.name |
| ABS | id_pid | id.pid == id.2 |
| THM | id_pid_wf | |
| DISP | id_pid_df | Parens ::Prec(pi1):: <t:id:*>.pid== <t>.pid |
| THM | id_name_rw | |
| THM | id_pid_rw | |
| DISP | z_id_eq_df | Parens ::Prec(atomrel)::Index 0 :: {[SOFT}<t1:id:L>{\\ }= {->0}<t2:id:L>{<-}{]} == <t1> = <t2> |
| ABS | z_id_eq | id1 = id2 == (id1.name) = (id2.name) |
| THM | z_id_eq_wf | |
| THM | z_id_eq_rw | |
| ML | z_id_eq_rw_simp | add_to_simpset `zbool_simps` (lemma_to_simp `z_id_eq_rw`) ;; |
| THM | z_id_neq_rw | |
| THM | truez_id_eq | |
| ML | z_id_eq_simp | add_to_simpset `zbool_iff_simps` (lemma_to_simp `truez_id_eq`) ;; |
| DISP | mesg_df | mesg== mesg |
| ABS | mesg | mesg == |
| THM | mesg_wf | mesg |
| THM | mesg_wf1 | mesg |
| DISP | mk_mesg_df | <T:T:*>(<args:args:*>)== <T>(<args>) |
| ABS | mk_mesg | T(args) == <T, args> |
| THM | mk_mesg_wf | |
| DISP | mesg_type_df | <M:M:*>.type== <M>.type |
| ABS | mesg_type | M.type == M.1 |
| THM | mesg_type_wf | |
| DISP | mesg_args_df | <M:M:*>.args== <M>.args |
| ABS | mesg_args | M.args == M.2 |
| THM | mesg_args_wf | |
| THM | mesg_char | |
| THM | mesg_type_rw | |
| THM | mesg_args_rw | |
| DISP | mesg_first_arg_df | mesg_first_arg(<M:M:*>)== mesg_first_arg(<M>) |
| ABS | mesg_first_arg | mesg_first_arg(M) == if null(M.args) then nil else hd(M.args) fi |
| THM | mesg_first_arg_wf | |
| THM | mesg_first_arg_rw | |
| THM | decidable__mesg_equality | |
| THM | decidable__mesg_list_el | |
| THM | decidable__exists_mesg_sender | |
| DISP | hist_el_df | hist_el== hist_el |
| ABS | hist_el | hist_el == o |
| THM | hist_el_wf | hist_el |
| THM | hist_el_wf1 | hist_el |
| DISP | mk_hist_el_df | mk_hist_el(<b:b:*><p:p:*><q:q:*><M:M:*>) == mk_hist_el(<b><p><q><M>) |
| ABS | mk_hist_el | mk_hist_el(b;p;q;M) == <b, p, q, M> |
| THM | mk_hist_el_wf | |
| DISP | he_send_df | <he:he:*>.send?== <he>.send? |
| ABS | he_send | he.send? == he.1 |
| THM | he_send_wf | |
| DISP | he_src_df | <he:he:*>.src== <he>.src |
| ABS | he_src | he.src == he.2.1 |
| THM | he_src_wf | |
| DISP | he_dest_df | <he:he:*>.dest== <he>.dest |
| ABS | he_dest | he.dest == he.2.2.1 |
| THM | he_dest_wf | |
| DISP | he_mesg_df | <he:he:*>.mesg== <he>.mesg |
| ABS | he_mesg | he.mesg == he.2.2.2 |
| THM | he_mesg_wf | |
| THM | hist_el_char | |
| THM | he_send_rw | |
| THM | he_src_rw | |
| THM | he_dest_rw | |
| THM | he_mesg_rw | |
| DISP | hist_df | hist== hist |
| ABS | hist | hist == hist_el List |
| THM | hist_wf | hist |
| ML | hist_soft | add_soft_abs ``hist``;; |
| DISP | state_df | state== state |
| ABS | state | state == (id |
| THM | state_wf | state |
| DISP | mk_state_df | mk_state(<v:v:*><h:h:*>)== mk_state(<v><h>) |
| ABS | mk_state | mk_state(v;h) == <v, h> |
| THM | mk_state_wf | |
| ABS | s_v | s.v == s.1 |
| THM | s_v_wf | |
| ABS | s_h | s.h == s.2 |
| THM | s_h_wf | |
| DISP | s_v_df | Parens ::Prec(pi1):: <t:state:*>.v== <t>.v |
| DISP | s_h_df | Parens ::Prec(pi1):: <t:state:*>.h== <t>.h |
| THM | state_v_rw | |
| THM | state_h_rw | |
| DISP | zexp_df | zexp== zexp |
| ABS | zexp | zexp == state |
| THM | zexp_wf | zexp |
| DISP | bexp_df | bexp== bexp |
| ABS | bexp | bexp == state |
| THM | bexp_wf | bexp |
| ML | zexp_ml_inc | add_set_inclusion_info `bexp` `zexp` AbSetDForInc Auto;; |
| THM | bexp_inc | bexp |
| DISP | mexp_df | mexp== mexp |
| ABS | mexp | mexp == state |
| THM | mexp_wf | mexp |
| DISP | com_df | com== com |
| ABS | com | com == state |
| THM | com_wf | com |
| ML | com_soft | add_soft_abs ``com``;; |
| ABS | prog | prog{} == com List |
| THM | prog_wf | prog{} |
| ABS | prog_actions | prg.actions == prg.1 |
| THM | prog_actions_wf | |
| ABS | prog_init | prg.init == prg.2 |
| THM | prog_init_wf | |
| DISP | prog_actions_df | Parens ::Prec(pi1):: <t:program:*>.actions== <t>.actions |
| DISP | prog_init_df | Parens ::Prec(pi1):: <t:program:*>.init== <t>.init |
| ABS | var_val | x |
| DISP | var_val_df | EdAlias ap ::Parens ::Prec(apply)::
{[SOFT}<x:id:E> |
| THM | var_val_wf | |
| ABS | eval | e |
| DISP | eval_df | EdAlias ap ::Parens ::Prec(apply)::
{[SOFT}<e:zexp:E> |
| THM | eval_wf | |
| THM | eval_wf1 | |
| DISP | mval_df | EdAlias ap ::Parens ::Prec(apply)::
{[SOFT}<M:mexp:E> |
| ABS | mval | M |
| THM | mval_wf | |
| ABS | cval | c |
| DISP | cval_df | EdAlias ap ::Parens ::Prec(apply)::
{[SOFT}<c:command:E> |
| THM | cval_wf | |
| ABS | zexp_val | zexp_val{}(s) == |
| THM | zexp_val_wf | |
| ML | zbool_iff_simpset2 | simpset_add `zbool_iff` (lemma_simp `truez_id_eq`) ;; |
| ML | zbool_simpset2 | simpset_add `zbool` (lemma_simp `z_id_eq_rw`) ;; |
| ML | base1_simpset1 | map ((simpset_add `base1`) o lemma_simp) ``he_send_rw he_src_rw he_dest_rw he_mesg_rw mesg_char mesg_type_rw mesg_args_rw mesg_first_arg_rw state_v_rw state_h_rw id_name_rw id_pid_rw``;; |
| COM | sci_base_3 | ---- Basic Expressions ----------------------------------- |
| DISP | eint_df | <x:int>== <x> |
| ABS | eint | n == |
| THM | eint_wf | |
| DISP | evar_df | <x:id>== <x> |
| ABS | evar | x == |
| THM | evar_wf | |
| DISP | emesg_df | <T:T:*>(<es:es:*>)== <T>(<es>) |
| ABS | emesg | T(es) == |
| THM | emesg_wf | |
| DISP | etrue_df | true== true |
| ABS | etrue | true == |
| THM | etrue_wf | true |
| DISP | efalse_df | false== false |
| ABS | efalse | false == |
| THM | efalse_wf | false |
| DISP | e_int_eq_df | Parens ::Prec(atomrel)::Index 0 :: {[SOFT}<t1:zexp:L>{\\ }= {->0}<t2:zexp:L>{<-}{]} == <t1> = <t2> |
| ABS | e_int_eq | m = n == |
| THM | e_int_eq_wf | |
| DISP | eand_df |
RAssoc Infix Display Form Generator
Prec: and
Slot Name: bexp
Infix Chars: " |
| ABS | eand | A |
| THM | eand_wf | |
| DISP | enot_df | Parens ::Prec(preop):: |
| ABS | enot | |
| THM | enot_wf | |
| DISP | eor_df |
RAssoc Infix Display Form Generator
Prec: or
Slot Name: bexp
Infix Chars: " |
| ABS | eor | A |
| THM | eor_wf | |
| COM | sci_base_4 | ---- Basic Commands ------------------------------------- |
| DISP | cseq_df | RAssoc Infix Display Form Generator Prec: cseq Slot Name: com Infix Chars: "" Term: c1,c2.c1 ;c2 |
| ABS | cseq | c1 ;c2 == |
| THM | cseq_wf | |
| DISP | cif_df | (if <b:bexp> then <s:command:*> else <t:command:E>) == (if <b> then <s> else <t>) |
| ABS | cif | (if b then c1 else c2) == |
| THM | cif_wf | |
| DISP | update_state_df | <st:state>[<x:id><-<v:zexp>]== <st>[<x><-<v>] |
| ABS | update_state | st[x<-v] == < |
| THM | update_state_wf | |
| DISP | cguard_df | <b:bexp> --> <c:command>== <b> --> <c> |
| ABS | cguard | b --> c == |
| THM | cguard_wf | |
| DISP | cskip_df | skip== skip |
| ABS | cskip | skip == |
| THM | cskip_wf | skip |
| DISP | cassign_df | <x:id>:=<e:zexp>== <x>:=<e> |
| ABS | cassign | x:=e == |
| THM | cassign_wf | |
| COM | sci_base_5 | ---- Send and Receive ------------------------------------ |
| DISP | update_hist_df | [<h:var><-<f:hist>]== [<h><-<f>] |
| ABS | update_hist | [h<-f[h]] == |
| THM | update_hist_wf | |
| DISP | set_send_df | set_send(<he:he:*><b:b:*>)== set_send(<he><b>) |
| ABS | set_send | set_send(he;b) == mk_hist_el(b;he.src;he.dest;he.mesg) |
| THM | set_send_wf | |
| DISP | bogus_he_df | bogus_he()== bogus_he() |
| ABS | bogus_he | bogus_he() == mk_hist_el(true;0;0;0([])) |
| THM | bogus_he_wf | bogus_he() |
| DISP | next_in_hist_df | next_in_hist(<h:h:*>)== next_in_hist(<h>) |
| ABS | next_in_hist | next_in_hist(h) == if znull(h) then bogus_he() else last_el(h) |
| THM | next_in_hist_wf | |
| THM | next_in_hist_char | next_in_hist([]) = bogus_he()
|
| DISP | aux_queue_df | aux_queue(<h:h:*>)== aux_queue(<h>) |
| ML | aux_queue_ml | aux_queue(h) ==r if znull(h) then [] else if hd(h).send? then hd(h) ::aux_queue(tl(h)) else but_last_el(aux_queue(tl(h))) |
| THM | aux_queue_wf | |
| THM | aux_queue_nil | aux_queue([]) = [] |
| THM | aux_queue_cons | |
| THM | aux_queue_listsubset | |
| THM | aux_queue_send | |
| DISP | raw_queue_df | raw_queue(<i:i:*><h:h:*>)== raw_queue(<i><h>) |
| ABS | raw_queue | raw_queue(i;h) == filter( |
| THM | raw_queue_wf | |
| THM | raw_queue_nil | |
| THM | raw_queue_cons | |
| THM | raw_queue_listsubset | |
| THM | raw_queue_dest | |
| DISP | queue_df | queue(<i:i:*><h:h:*>)== queue(<i><h>) |
| ABS | queue | queue(i;h) == aux_queue(raw_queue(i;h)) |
| THM | queue_wf | |
| THM | queue_nil | |
| THM | queue_listsubset | |
| DISP | next_he_df | next_he(<dest:dest:*><h:h:*>)== next_he(<dest><h>) |
| ABS | next_he | next_he(dest;h) == next_in_hist(queue(dest;h)) |
| THM | next_he_wf | |
| DISP | next_mesg_df | next_mesg(<dest:dest:*><h:h:*>)== next_mesg(<dest><h>) |
| ABS | next_mesg | next_mesg(dest;h) == next_he(dest;h).mesg |
| THM | next_mesg_wf | |
| THM | next_he_send | |
| THM | next_he_dest | |
| THM | next_he_mesg | |
| THM | next_he_char | |
| ABS | bmsg_p | msg?(dest,T) == |
| DISP | bmsg_p_df | msg?(<dest:pid>,<T:msg_t>)== msg?(<dest>,<T>) |
| THM | bmsg_p_wf | |
| THM | bmsg_p_in_hist | |
| THM | next_mesg_in_hist | |
| THM | next_he_in_hist | |
| THM | received_mesg_in_hist | |
| DISP | assign_args_df | assign_args(<vs:vs:*><vals:vals:*>)== assign_args(<vs><vals>) |
| ML | assign_args_ml | assign_args(vs;vals) ==r if znull(vs) then skip else if znull(vals) then hd(vs):=0 ;assign_args(tl(vs);vals) else (hd(vs):=hd(vals) ;assign_args(tl(vs);tl(vals))) |
| THM | assign_args_wf | |
| THM | assign_args_char | ( |
| DISP | assign_msg_args_df | assign_msg_args(<dest:dest:*><argvs:argvs:*>) == assign_msg_args(<dest><argvs>) |
| ABS | assign_msg_args | assign_msg_args(dest;argvs) ==
|
| THM | assign_msg_args_wf | |
| DISP | hsend_df | hsend(<src:src:*><dest:dest:*><M:M:*>)== hsend(<src><dest><M>) |
| ABS | hsend | hsend(src;dest;M) == mk_hist_el(true;src;dest;M) |
| THM | hsend_wf | |
| THM | hsend_he_send_rw | |
| DISP | hreceive_df | hreceive(<dest:dest:*><h:h:*>)== hreceive(<dest><h>) |
| ABS | hreceive | hreceive(dest;h) == set_send(next_he(dest;h);false) |
| THM | hreceive_wf | |
| THM | hreceive_he_send_rw | |
| THM | hreceived_mesg_in_hist | |
| ABS | csend | src->dest!M == |
| DISP | csend_df | <src:pid>-><dest:zexp>!<M:mexp>== <src>-><dest>!<M> <dest:zexp>!<M:mexp>== <dest>!<M> <dest:zexp>!<M:mexp>== <dest>!<M> |
| THM | csend_wf | |
| ABS | creceive | receive(dest,argvs) == assign_msg_args(dest;argvs) ;[h<-(hreceive(dest;h)::h)] |
| DISP | creceive_df | receive(<dest:pid>,<argvs:ids>)== receive(<dest>,<argvs>) |
| THM | creceive_wf | |
| ABS | cguard_rec | dest?T(argvs) --> c == msg?(dest,T) --> (receive(dest,argvs) ;c) |
| DISP | cguard_rec_df | <dest:pid>?<T:msg_t>(<argvs:ids>) --> <c:com> == <dest>?<T>(<argvs>) --> <c> |
| THM | cguard_rec_wf | |
| ML | base_simpset1 | map (simpset_add `base`) (lemma_simps `next_in_hist_char`) ;; map ((simpset_add `base`) o lemma_simp) ``aux_queue_nil raw_queue_nil queue_nil next_he_send next_he_dest ne xt_he_mesg`` ;; map (simpset_add `base`) (lemma_simps `assign_args_char`);; |
| COM | sci_base_6 | ---- Buffers and Histories ------------------------------ |
| ABS | buf | buf[p] |
| DISP | buf_df | EdAlias ap ::Parens ::Prec(apply)::
{[SOFT}buf[<p:pid:E>] |
| THM | buf_wf | |
| DISP | inbuf_df | Parens ::Prec(atomrel)::
{->0}<M:M:*>{<-}{\\? } |
| ABS | inbuf | M |
| THM | inbuf_wf | |
| THM | inbuf_sent | |
| THM | buf_not_empty | |
| THM | next_mesg_last_el | |
| THM | next_mesg_in_buf | |
| THM | next_mesg_in_buf_f | |
| ML | base_simpset2 | simpset_add `base` (unfold_top_simp `inbuf`) ;; simpset_add `base` (unfold_top_simp `mk_id`) ;; |
| ML | base1_simpset2 | map ((simpset_add `base1`) o lemma_simp) ``hsend_he_send_rw hreceive_he_send_rw`` ;; |
| COM | sci_base_7 | ---- Trace Semantics ------------------------------------- |
| ABS | in_prog | in_prog{}(a; prg) == list_el(com;a;prg.actions) |
| THM | in_prog_wf | |
| ABS | enabled | enabled{}(s; a) == |
| THM | enabled_wf | |
| ABS | trace | trace{} == |
| THM | trace_wf | trace{} |
| ABS | tval | tr |
| THM | tval_wf | |
| DISP | tval_df | EdAlias ap ::Parens ::Prec(apply)::
{[SOFT}<tr:trace:E> |
| ABS | trace_of | trace_of{}(prg; tr) ==
( |
| THM | trace_of_wf | |
| ABS | weak_fair | weak_fair{}(p; tr) ==
|
| THM | weak_fair_wf | |
| ABS | strong_fair | strong_fair{}(p; tr) ==
|
| THM | strong_fair_wf | |
| ABS | in_trace | in_trace{}(s; tr) == |
| THM | in_trace_wf | |
| ABS | in_exec | in_exec{}(prg; s) ==
|
| THM | in_exec_wf | |
| THM | next_in_exec | |
| ABS | in_weak_fair_exec | in_weak_fair_exec{}(prg; s) ==
|
| THM | in_weak_fair_exec_wf | |
| ABS | in_strong_fair_exec | in_strong_fair_exec{}(prg; s) ==
|
| THM | in_strong_fair_exec_wf | |
| ABS | in_exec_pr | in_exec_pr{}(prg; s; s') ==
|
| THM | in_exec_pr_wf | |
| COM | sci_base_8 | ---- Logic ----------------------------------------------- |
| DISP | htriple_df | htriple(<s:var>.<A:A:*><prg:prg:*><s:var>.<B:B:*>) == htriple(<s>.<A><prg><s>.<B>) |
| ABS | htriple | htriple(s.A[s];prg;s.B[s]) ==
|
| THM | htriple_wf | |
| THM | htriple_conj | |
| THM | htriple_pre_conj | |
| THM | htriple_discharge | |
| ABS | inv | inv{}(prg; s.I[s]) == |
| THM | inv_wf | |
| THM | decomp_inv | |
| THM | decomp_inv_pr | |
| THM | inv_weaken | |
| THM | htriple_inv | |
| ABS | inv_W | inv_W{}(prg; s.P[s]; s.Q[s]) ==
|
| THM | inv_W_wf | |
| ABS | inv_U | inv_U{}(prg; s.P[s]; s.Q[s]) ==
|
| THM | inv_U_wf |