▶
algebra/1307/2464 (53%)| Rocq Name | Status | Details |
|---|---|---|
| agree | Iris.Agree | |
| agreeO | Use Agree with a typeclass instance instead. | |
| agreeO_map | Iris.Agree.map_hom | |
| agreeO_map_ne | Iris.Agree.map_ne | |
| agreeR | Use the plain Agree type with a typeclass instance instead. | |
| agreeRF | Iris.AgreeRF | |
| agreeRF_contractive | Iris.instRFunctorContractiveAgreeRFOfOFunctorContractive | |
| agree_assoc | Iris.Agree.op_assoc | |
| agree_cancelable | Iris.instCancelableAgree | |
| agree_cmra_discrete | Iris.instDiscreteAgreeOfDiscrete | |
| agree_cmra_mixin | Iris.instCMRAAgree | |
| agree_cmra_total | Iris.instIsTotalAgree | |
| agree_comm | Iris.Agree.op_comm | |
| agree_core_id | Iris.instCoreIdAgreeToAgree | |
| agree_dist | Iris.Agree.dist | |
| agree_eq | Iris.Agree.ext | |
| agree_equiv | Defined in Agree OFE instance. | |
| agree_idemp | Iris.Agree.idemp | |
| agree_included | Iris.Agree.included | |
| agree_includedN | Iris.Agree.includedN | |
| agree_map | Iris.Agree.map' | |
| agree_map_compose | Iris.Agree.map_compose | |
| agree_map_ext | Iris.Agree.agree_map_ext | |
| agree_map_id | Iris.Agree.map_id | |
| agree_map_morphism | Iris.Agree.map | |
| agree_map_ne | Iris.instNonExpansive_AgreeMap' | |
| agree_map_proper | Derivable from instNonExpansive_AgreeMap' with NonExpansive.eqv | |
| agree_map_to_agree | Iris.Agree.map_toAgree | |
| agree_ofe_mixin | Iris.instOFE_agree | |
| agree_op_instance | Use the CMRA instance instead. | |
| agree_op_inv | Iris.Agree.op_inv | |
| agree_op_invN | Iris.Agree.op_invN | |
| agree_op_ne | Iris.Agree.op_ne₂ | |
| agree_op_ne' | Iris.Agree.op_ne | |
| agree_op_proper | Derivable from Agree.op_ne₂ using NonExpansive₂.eqv | |
| agree_pcore | Iris.Agree.pcore_some | |
| agree_pcore_instance | Use the CMRA instance instead. | |
| agree_validN_def | Iris.Agree.validN_iff | |
| agree_validN_instance | Use the CMRA instance instead. | |
| agree_validN_ne | Iris.Agree.validN_ne | |
| agree_validN_proper | Derivable from Agree.validN_ne using NonExpansive.eqv | |
| agree_valid_included | Iris.Agree.valid_included | |
| agree_valid_includedN | Iris.Agree.valid_includedN | |
| agree_valid_instance | Use the CMRA instance instead. | |
| elem_of_agree | Iris.mem_of_agree | |
| to_agree | Iris.toAgree | |
| to_agree_discrete | Iris.Agree.toAgree.is_discrete | |
| to_agree_included | Iris.Agree.toAgree_included | |
| to_agree_includedN | Iris.Agree.toAgree_includedN | |
| to_agree_included_L | Iris.Agree.toAgree_included_L | |
| to_agree_inj | Iris.Agree.toAgree_inj | |
| to_agree_injN | Iris.Agree.toAgree_injN | |
| to_agree_ne | Iris.instNonExpansive_toAgree | |
| to_agree_op_inv | Use the general op_invN theorem. | |
| to_agree_op_invN | Use the general op_inv theorem. | |
| to_agree_op_inv_L | Use toAgree_op_valid_iff_eq | |
| to_agree_op_valid | Iris.Agree.toAgree_op_valid_iff_equiv | |
| to_agree_op_validN | Iris.Agree.toAgree_op_validN_iff_dist | |
| to_agree_op_valid_L | Iris.toAgree_op_valid_iff_eq | |
| to_agree_proper | Derivable from instNonExpansive_toAgree with NonExpansive.eqv | |
| to_agree_uninj | Iris.Agree.toAgree_uninj | |
| to_agree_uninjN | Iris.Agree.toAgree_uninjN |
| Rocq Name | Status | Details |
|---|---|---|
| auth_frag_sep_homomorphism | ||
| big_opL_auth_frag | ||
| big_opMS_auth_frag | ||
| big_opM_auth_frag | ||
| big_opS_auth_frag | ||
| authO | Use the Auth type and View.instOFE typeclass | |
| authR | Use the Auth type and View.instCMRA typeclass | |
| authRF | Auth.AuthRF | |
| authRF_contractive | Auth.instRFunctorContractiveAuthRF | |
| authUR | Use the Auth type and View.instUCMRA typeclass | |
| authURF | Auth.AuthURF | |
| authURF_contractive | Auth.instURFunctorContractiveAuthURF | |
| auth_auth | Auth.auth | |
| auth_auth_core_id | Auth.instCoreIdAuthDiscard | |
| auth_auth_dfrac_included | Auth.auth_dfrac_included | |
| auth_auth_dfrac_includedN | Auth.auth_dfrac_includedN | |
| auth_auth_dfrac_is_op | Auth.instIsOpAuthOfDFrac | |
| auth_auth_dfrac_op | Auth.auth_dfrac_op | |
| auth_auth_dfrac_op_inv | Auth.auth_dfrac_op_inv | |
| auth_auth_dfrac_op_invN | Auth.auth_dfrac_op_invN | |
| auth_auth_dfrac_op_inv_L | Auth.auth_dfrac_op_inv_L | |
| auth_auth_dfrac_op_valid | Auth.auth_dfrac_op_valid | |
| auth_auth_dfrac_op_validN | Auth.auth_dfrac_op_validN | |
| auth_auth_dfrac_valid | Auth.auth_dfrac_valid | |
| auth_auth_dfrac_validN | Auth.auth_dfrac_validN | |
| auth_auth_discrete | Auth.auth_discrete | |
| auth_auth_dist_inj | Auth.auth_dist_inj | |
| auth_auth_included | Auth.auth_included | |
| auth_auth_includedN | Auth.auth_includedN | |
| auth_auth_inj | Auth.auth_inj | |
| auth_auth_ne | Auth.auth_ne | |
| auth_auth_op_valid | Auth.auth_op_valid | |
| auth_auth_op_validN | Auth.auth_op_validN | |
| auth_auth_proper | Derivable from auth_ne with NonExpansive.eqv | |
| auth_auth_valid | Auth.auth_valid | |
| auth_auth_validN | Auth.auth_validN | |
| auth_both_core_discarded | Auth.auth_both_core_discarded | |
| auth_both_core_frac | Auth.auth_both_core_frac | |
| auth_both_core_id | Auth.instCoreIdOpAuthDiscardFrag | |
| auth_both_dfrac_included | Auth.auth_both_dfrac_included | |
| auth_both_dfrac_includedN | Auth.auth_both_dfrac_includedN | |
| auth_both_dfrac_valid | Auth.both_dfrac_valid | |
| auth_both_dfrac_validN | Auth.both_dfrac_validN | |
| auth_both_dfrac_valid_2 | Auth.auth_both_dfrac_valid_2 | |
| auth_both_dfrac_valid_discrete | Auth.both_dfrac_valid_discrete | |
| auth_both_included | Auth.auth_both_included | |
| auth_both_includedN | Auth.auth_both_includedN | |
| auth_both_valid | Auth.auth_both_valid | |
| auth_both_validN | Auth.both_validN | |
| auth_both_valid_2 | Auth.auth_both_valid_2 | |
| auth_both_valid_discrete | Auth.auth_both_valid_discrete | |
| auth_cmra_discrete | Inference succeeds automatically | |
| auth_frag | Auth.frag | |
| auth_frag_core | Auth.frag_core | |
| auth_frag_core_id | Auth.instCoreIdFrag | |
| auth_frag_discrete | Auth.frag_discrete | |
| auth_frag_dist_inj | Auth.frag_dist_inj | |
| auth_frag_included | Auth.frag_included | |
| auth_frag_includedN | Auth.frag_includedN | |
| auth_frag_inj | Auth.frag_inj | |
| auth_frag_is_op | Auth.instIsOpFrag | |
| auth_frag_mono | Auth.frag_inc_of_inc | |
| auth_frag_ne | Auth.frag_ne | |
| auth_frag_op | Auth.frag_op | |
| auth_frag_op_valid | Auth.frag_op_valid | |
| auth_frag_op_validN | Auth.frag_op_validN | |
| auth_frag_op_validN_1 | Use frag_op_validN | |
| auth_frag_op_validN_2 | Use frag_op_validN | |
| auth_frag_op_valid_1 | Use frag_op_valid | |
| auth_frag_op_valid_2 | Use frag_op_valid | |
| auth_frag_proper | Derivable from frag_ne with NonExpansive.eqv | |
| auth_frag_valid | Auth.frag_valid | |
| auth_frag_validN | Auth.frag_validN | |
| auth_frag_validN_1 | Use frag_validN.mp | |
| auth_frag_validN_2 | Use frag_validN.mpr | |
| auth_frag_valid_1 | Use frag_valid | |
| auth_frag_valid_2 | Use frag_valid | |
| auth_local_update | Auth.auth_local_update | |
| auth_ofe_discrete | Inference succeeds automatically | |
| auth_update | Auth.auth_update | |
| auth_updateP_auth_unpersist | Auth.auth_updateP_auth_unpersist | |
| auth_updateP_both_unpersist | Auth.auth_updateP_both_unpersist | |
| auth_update_alloc | Auth.auth_update_alloc | |
| auth_update_auth | Auth.auth_update_auth | |
| auth_update_auth_persist | Auth.auth_update_auth_persist | |
| auth_update_dealloc | Auth.auth_update_dealloc | |
| auth_update_dfrac_alloc | Auth.auth_update_dfrac_alloc | |
| auth_view_rel | AuthViewRel.instViewRel_authViewRel | |
| auth_view_rel_discrete | AuthViewRel.instIsViewRelDiscreteOfDiscreteOfDiscrete | |
| auth_view_rel_exists | AuthViewRel.authViewRel_exists_iff | |
| auth_view_rel_raw | AuthViewRel | |
| auth_view_rel_raw_mono | Use the IsViewRel typeclass | |
| auth_view_rel_raw_unit | Use the IsViewRel typeclass | |
| auth_view_rel_raw_valid | Use the IsViewRel typeclass | |
| auth_view_rel_unit | AuthViewRel.authViewRel_unit_iff |
| Rocq Name | Status | Details |
|---|---|---|
| big_opL_commute1_L | ||
| big_opL_commute_L | ||
| big_opL_consZ_l | ||
| big_opL_consZ_r | ||
| big_opL_opL | ||
| big_opL_opM | ||
| big_opL_opMS | ||
| big_opL_opS | ||
| big_opL_zip_seq | ||
| big_opL_zip_seqZ | ||
| big_opMS | ||
| big_opMS_aux | ||
| big_opMS_closed | ||
| big_opMS_commute | ||
| big_opMS_commute1 | ||
| big_opMS_commute1_L | ||
| big_opMS_commute_L | ||
| big_opMS_def | ||
| big_opMS_delete | ||
| big_opMS_disj_union | ||
| big_opMS_elements | ||
| big_opMS_empty | ||
| big_opMS_ext | ||
| big_opMS_gen_proper | ||
| big_opMS_insert | ||
| big_opMS_ne | ||
| big_opMS_ne' | ||
| big_opMS_op | ||
| big_opMS_opL | ||
| big_opMS_opM | ||
| big_opMS_opMS | ||
| big_opMS_opS | ||
| big_opMS_proper | ||
| big_opMS_proper' | ||
| big_opMS_singleton | ||
| big_opMS_unit | ||
| big_opMS_unseal | ||
| big_opM_commute1_L | ||
| big_opM_commute_L | ||
| big_opM_dom | ||
| big_opM_gset_to_gmap | ||
| big_opM_kmap | ||
| big_opM_map_seq | ||
| big_opM_map_seqZ | ||
| big_opM_opL | ||
| big_opM_opM | ||
| big_opM_opMS | ||
| big_opM_opS | ||
| big_opM_set_to_map | ||
| big_opS_commute1_L | ||
| big_opS_commute_L | ||
| big_opS_delete | ||
| big_opS_filter' | ||
| big_opS_fn_insert | ||
| big_opS_fn_insert' | ||
| big_opS_list_to_set | ||
| big_opS_opL | ||
| big_opS_opM | ||
| big_opS_opMS | ||
| big_opS_opS | ||
| big_opS_set_map | ||
| big_opL | Iris.Algebra.bigOpL | |
| big_opL_app | Iris.Algebra.BigOpL.bigOpL_append_eqv | |
| big_opL_bind | Iris.Algebra.BigOpL.bigOpL_flatMap_eqv | |
| big_opL_closed | Iris.Algebra.BigOpL.bigOpL_closed | |
| big_opL_commute | Iris.Algebra.BigOpL.bigOpL_hom | |
| big_opL_commute1 | Iris.Algebra.BigOpL.bigOpL_hom_weak | |
| big_opL_cons | Iris.Algebra.BigOpL.bigOpL_cons | |
| big_opL_ext | Iris.Algebra.BigOpL.bigOpL_ext | |
| big_opL_fmap | Iris.Algebra.BigOpL.bigOpL_map_eqv | |
| big_opL_gen_proper | Iris.Algebra.BigOpL.bigOpL_gen_proper | |
| big_opL_gen_proper_2 | Iris.Algebra.BigOpL.bigOpL_gen_proper_2 | |
| big_opL_ne | Iris.Algebra.BigOpL.bigOpL_dist | |
| big_opL_ne' | Use bigOpL_dist | |
| big_opL_nil | Iris.Algebra.BigOpL.bigOpL_nil | |
| big_opL_omap | Iris.Algebra.BigOpL.bigOpL_filterMap_eqv | |
| big_opL_op | Iris.Algebra.BigOpL.bigOpL_op_eqv | |
| big_opL_permutation | Iris.Algebra.BigOpL.bigOpL_eqv_of_perm | |
| big_opL_permutation' | Use bigOpL_eqv_of_perm | |
| big_opL_proper | Iris.Algebra.BigOpL.bigOpL_eqv | |
| big_opL_proper' | Use bigOpL_eqv | |
| big_opL_proper_2 | Iris.Algebra.BigOpL.bigOpL_proper_2 | |
| big_opL_sep_zip | Iris.Algebra.BigOpL.bigOpL_zip_op_eqv | |
| big_opL_sep_zip_with | Iris.Algebra.BigOpL.bigOpL_zipWith_op_eqv | |
| big_opL_singleton | Iris.Algebra.BigOpL.bigOpL_singleton_eqv | |
| big_opL_snoc | Iris.Algebra.BigOpL.bigOpL_snoc_eqv | |
| big_opL_take_drop | Iris.Algebra.BigOpL.bigOpL_take_drop_eqv | |
| big_opL_unit | Iris.Algebra.BigOpL.bigOpL_const_unit_eqv | |
| big_opM | Iris.Algebra.bigOpM | |
| big_opM_aux | Not needed | |
| big_opM_closed | Iris.Algebra.BigOpM.bigOpM_closed | |
| big_opM_commute | Iris.Algebra.BigOpM.bigOpM_hom | |
| big_opM_commute1 | Iris.Algebra.BigOpM.bigOpM_weak_hom | |
| big_opM_def | Not needed | |
| big_opM_delete | Iris.Algebra.BigOpM.bigOpM_delete_eqv | |
| big_opM_empty | Iris.Algebra.BigOpM.bigOpM_empty | |
| big_opM_ext | Iris.Algebra.BigOpM.bigOpM_ext | |
| big_opM_filter' | Iris.Algebra.BigOpM.bigOpM_filter_eqv | |
| big_opM_fmap | Iris.Algebra.BigOpM.bigOpM_map_eqv | |
| big_opM_fn_insert | Iris.Algebra.BigOpM.bigOpM_fn_insert_eqv | |
| big_opM_fn_insert' | Iris.Algebra.BigOpM.bigOpM_fn_insert_eqv' | |
| big_opM_gen_proper | Iris.Algebra.BigOpM.bigOpM_gen_eqv | |
| big_opM_gen_proper_2 | Iris.Algebra.BigOpM.bigOpM_gen_proper_2 | |
| big_opM_insert | Iris.Algebra.BigOpM.bigOpM_insert_eqv | |
| big_opM_insert_delete | Iris.Algebra.BigOpM.bigOpM_insert_delete_eqv | |
| big_opM_insert_override | Iris.Algebra.BigOpM.bigOpM_insert_override_eqv | |
| big_opM_list_to_map | Iris.Algebra.BigOpM.bigOpM_ofList_eqv | |
| big_opM_map_to_list | Iris.Algebra.BigOpM.bigOpM_toList_eqv | |
| big_opM_ne | Iris.Algebra.BigOpM.bigOpM_dist | |
| big_opM_ne' | Use bigOpM_dist | |
| big_opM_omap | Iris.Algebra.BigOpM.bigOpM_filterMap_eqv | |
| big_opM_op | Iris.Algebra.BigOpM.bigOpM_op_eqv | |
| big_opM_proper | Iris.Algebra.BigOpM.bigOpM_eqv | |
| big_opM_proper' | Use bigOpM_eqv | |
| big_opM_proper_2 | Iris.Algebra.BigOpM.bigOpM_eqv_strong | |
| big_opM_sep_zip | Iris.Algebra.BigOpM.bigOpM_sep_zip_eqv | |
| big_opM_sep_zip_with | Iris.Algebra.BigOpM.bigOpM_sep_zipWith_eqv | |
| big_opM_singleton | Iris.Algebra.BigOpM.bigOpM_singleton_eqv | |
| big_opM_union | Iris.Algebra.BigOpM.bigOpM_union_eqv | |
| big_opM_unit | Iris.Algebra.BigOpM.bigOpM_const_unit_eqv | |
| big_opM_unseal | Not needed | |
| big_opS | Iris.Algebra.bigOpS | |
| big_opS_aux | Not needed | |
| big_opS_closed | Iris.Algebra.BigOpS.bigOpS_closed | |
| big_opS_commute | Iris.Algebra.BigOpS.hom | |
| big_opS_commute1 | Iris.Algebra.BigOpS.hom_weak | |
| big_opS_def | Not needed | |
| big_opS_elements | Iris.Algebra.BigOpS.bigOpS_bigOpL | |
| big_opS_empty | Iris.Algebra.BigOpS.bigOpS_empty | |
| big_opS_ext | Iris.Algebra.BigOpS.bigOpS_ext | |
| big_opS_gen_proper | Iris.Algebra.BigOpS.bigOpS_gen_eqv | |
| big_opS_insert | Iris.Algebra.BigOpS.bigOpS_insert | |
| big_opS_ne | Iris.Algebra.BigOpS.bigOpS_dist | |
| big_opS_ne' | Use bigOpS_dist | |
| big_opS_op | Iris.Algebra.BigOpS.bigOpS_op_eqv | |
| big_opS_proper | Iris.Algebra.BigOpS.bigOpS_eqv | |
| big_opS_proper' | Use bigOpS_eqv | |
| big_opS_singleton | Iris.Algebra.BigOpS.bigOpS_singleton | |
| big_opS_union | Iris.Algebra.BigOpS.bigOpS_union | |
| big_opS_unit | Iris.Algebra.BigOpS.bigOpS_const_unit | |
| big_opS_unseal | Not needed |
| Rocq Name | Status | Details |
|---|---|---|
| Empty_setR | ||
| Empty_set_cancelable | ||
| Empty_set_cmra_discrete | ||
| Empty_set_cmra_mixin | ||
| Empty_set_core_id | ||
| Empty_set_op_instance | ||
| Empty_set_pcore_instance | ||
| Empty_set_validN_instance | ||
| Empty_set_valid_instance | ||
| RAMixin | ||
| Some_includedN_1 | ||
| Some_includedN_2 | ||
| Some_includedN_is_Some | ||
| Some_includedN_mono | ||
| Some_includedN_refl | ||
| Some_included_1 | ||
| Some_included_2 | ||
| Some_included_is_Some | ||
| Some_included_mono | ||
| Some_included_refl | ||
| Some_pair_included | ||
| Some_pair_includedN | ||
| Some_pair_includedN_l | ||
| Some_pair_includedN_r | ||
| Some_pair_includedN_total_1 | ||
| Some_pair_includedN_total_2 | ||
| Some_pair_included_l | ||
| Some_pair_included_r | ||
| Some_pair_included_total_1 | ||
| Some_pair_included_total_2 | ||
| cmra_includedN_preorder | ||
| cmra_included_preorder | ||
| cmra_morphism_compose | ||
| cmra_opM_fmap_Some | ||
| cmra_opM_opM_assoc_L | ||
| cmra_opM_opM_swap | ||
| cmra_opM_opM_swap_L | ||
| cmra_transport | ||
| cmra_transport_core | ||
| cmra_transport_core_id | ||
| cmra_transport_discrete | ||
| cmra_transport_ne | ||
| cmra_transport_op | ||
| cmra_transport_proper | ||
| cmra_transport_trans | ||
| cmra_transport_valid | ||
| cmra_transport_validN | ||
| constURF | ||
| constURF_contractive | ||
| discrete_fun_included_spec | ||
| discrete_fun_included_spec_1 | ||
| discrete_fun_lookup_core | ||
| discrete_fun_lookup_empty | ||
| discrete_fun_lookup_op | ||
| discrete_fun_map_cmra_morphism | ||
| discrete_fun_unit_discrete | ||
| id_free_ne | ||
| inj_cmra_mixin_restrict_validity | ||
| is_Some_included | ||
| is_Some_includedN | ||
| iso_cmra_mixin | ||
| iso_cmra_mixin_restrict_validity | ||
| optionRF | ||
| optionRF_contractive | ||
| option_fmap_cmra_morphism | ||
| option_fmap_mono | ||
| pair_cancelable | ||
| pair_core | ||
| pair_core_id | ||
| pair_exclusive_l | ||
| pair_exclusive_r | ||
| pair_id_free_l | ||
| pair_id_free_r | ||
| pair_included | ||
| pair_op | ||
| pair_op_1 | ||
| pair_op_1_L | ||
| pair_op_2 | ||
| pair_op_2_L | ||
| pair_pcore | ||
| pair_split | ||
| pair_split_L | ||
| pair_valid | ||
| pair_validN | ||
| prodUR | ||
| prodURF | ||
| prodURF_contractive | ||
| prod_cmra_total | ||
| prod_included | ||
| prod_includedN | ||
| prod_pcore_Some | ||
| prod_pcore_Some' | ||
| prod_ucmra_mixin | ||
| prod_unit_instance | ||
| rFunctor_apply | ||
| rFunctor_oFunctor_compose | ||
| rFunctor_oFunctor_compose_contractive_1 | ||
| rFunctor_oFunctor_compose_contractive_2 | ||
| ra_total_mixin | ||
| unitUR | ||
| unit_cmra_discrete | ||
| unit_ucmra_mixin | ||
| unit_unit_instance | ||
| urFunctor_apply | ||
| urFunctor_oFunctor_compose | ||
| urFunctor_oFunctor_compose_contractive_1 | ||
| urFunctor_oFunctor_compose_contractive_2 | ||
| Cancelable | Iris.CMRA.Cancelable | |
| Cancelable_proper | Derived from nonexpansivity | |
| CmraDiscrete | Iris.CMRA.Discrete | |
| CmraMixin | Use the CMRA type class. | |
| CmraMorphism | Iris.CMRA.Hom | |
| CmraTotal | Iris.CMRA.IsTotal | |
| CoreId | Iris.CMRA.CoreId | |
| CoreId_proper | Iris.CMRA.coreId_iff | |
| Exclusive | Iris.CMRA.Exclusive | |
| Exclusive_proper | Iris.CMRA.exclusive_iff | |
| IdFree | Iris.CMRA.IdFree | |
| IdFree_proper | Derived from nonexpansivity | |
| Op | Use the CMRA.op field. | |
| PCore | Use the CMRA.pcore field. | |
| Some_core | Iris.Option.some_core | |
| Some_core_id | Iris.Option.some_core_id | |
| Some_included | Iris.Option.some_inc_some_iff | |
| Some_includedN | Iris.Option.some_incN_some_iff | |
| Some_includedN_exclusive | Iris.Option.dist_of_inc_exclusive | |
| Some_includedN_opM | Iris.Option.some_incN_some_iff_opM | |
| Some_includedN_total | Iris.Option.some_incN_some_iff_is_total | |
| Some_included_exclusive | Iris.Option.eqv_of_inc_exclusive | |
| Some_included_opM | Iris.Option.some_inc_some_iff_opM | |
| Some_included_total | Iris.Option.some_inc_some_iff_is_total | |
| Some_op | Iris.Option.some_op | |
| Some_op_opM | Iris.Option.some_op_opM | |
| Some_valid | Iris.Option.some_valid | |
| Some_validN | Iris.Option.some_validN | |
| UcmraMixin | Lean uses the UCMRA type class directly; mixin/bundle separation is unnecessary. | |
| Unit | Lean uses the UCMRA.unit field; no separate class needed. | |
| Valid | Use the CMRA.Valid field. | |
| ValidN | Use the CMRA.ValidN field. | |
| cancelable | Iris.CMRA.cancelable | |
| cancelable_Some | Iris.Option.instCancelableOptionSomeOfIdFree | |
| cancelable_op | Iris.CMRA.cancelable_op | |
| cancelable_proper | Iris.CMRA.cancelable_iff | |
| cmra | Iris.CMRA | |
| cmra_assoc | Iris.CMRA.assoc' | |
| cmra_assoc_L | Iris.CMRA.assoc_L | |
| cmra_comm | Iris.CMRA.comm' | |
| cmra_comm_L | Iris.CMRA.comm_L | |
| cmra_core_core_id | Iris.CMRA.instCoreIdCore | |
| cmra_core_dup | Iris.CMRA.core_op_core | |
| cmra_core_dup_L | Iris.CMRA.core_op_core_L | |
| cmra_core_idemp | Iris.CMRA.core_idem | |
| cmra_core_idemp_L | Iris.CMRA.core_idem_L | |
| cmra_core_l | Iris.CMRA.core_op | |
| cmra_core_l_L | Iris.CMRA.core_op_L | |
| cmra_core_mono | Iris.CMRA.core_mono | |
| cmra_core_monoN | Iris.CMRA.core_incN_core | |
| cmra_core_ne | Iris.CMRA.core_ne | |
| cmra_core_proper | Derived from core_ne | |
| cmra_core_r | Iris.CMRA.op_core | |
| cmra_core_r_L | Iris.CMRA.op_core_L | |
| cmra_core_valid | Iris.CMRA.valid_core | |
| cmra_core_validN | Iris.CMRA.validN_core | |
| cmra_discrete_included_iff | Iris.CMRA.inc_iff_incN | |
| cmra_discrete_included_iff_0 | Iris.CMRA.inc_0_iff_incN | |
| cmra_discrete_included_l | Iris.CMRA.discrete_inc_l | |
| cmra_discrete_included_r | Iris.CMRA.discrete_inc_r | |
| cmra_discrete_valid_iff | Iris.CMRA.valid_iff_validN' | |
| cmra_discrete_valid_iff_0 | Iris.CMRA.valid_0_iff_validN | |
| cmra_extend | Iris.CMRA.extend' | |
| cmra_includedN_l | Iris.CMRA.incN_op_left | |
| cmra_includedN_le | Iris.CMRA.incN_of_incN_le | |
| cmra_includedN_ne | Iris.CMRA.incN_dist_iff | |
| cmra_includedN_proper | Iris.CMRA.incN_eqv_iff | |
| cmra_includedN_r | Iris.CMRA.incN_op_right | |
| cmra_includedN_trans | Iris.CMRA.incN_trans | |
| cmra_included_core | Iris.CMRA.core_inc_self | |
| cmra_included_dist_l | Iris.CMRA.included_dist_l | |
| cmra_included_includedN | Iris.CMRA.incN_of_inc | |
| cmra_included_l | Iris.CMRA.inc_op_left | |
| cmra_included_pcore | Iris.CMRA.pcore_inc_self | |
| cmra_included_proper | Iris.CMRA.inc_iff | |
| cmra_included_r | Iris.CMRA.inc_op_right | |
| cmra_included_trans | Iris.CMRA.inc_trans | |
| cmra_mixin_of' | Not needed. | |
| cmra_mono | Iris.CMRA.op_mono | |
| cmra_mono' | Use cmra_mono | |
| cmra_monoN | Iris.CMRA.op_monoN | |
| cmra_monoN' | Use cmra_monoN | |
| cmra_monoN_l | Iris.CMRA.op_monoN_right | |
| cmra_monoN_r | Iris.CMRA.op_monoN_left | |
| cmra_mono_l | Iris.CMRA.op_mono_right | |
| cmra_mono_r | Iris.CMRA.op_mono_left | |
| cmra_monoid | Iris.CMRA.ucmraMonoidOps | |
| cmra_morphism_core | Iris.CMRA.Hom.core | |
| cmra_morphism_id | Iris.CMRA.Hom.id | |
| cmra_morphism_mono | Iris.CMRA.Hom.mono | |
| cmra_morphism_monoN | Iris.CMRA.Hom.monoN | |
| cmra_morphism_proper | Iris.CMRA.Hom.eqv | |
| cmra_morphism_valid | Iris.CMRA.Hom.valid | |
| cmra_ofeO | Not needed. | |
| cmra_opM_ne | Iris.CMRA.instNonExpansive₂OptionOp? | |
| cmra_opM_opM_assoc | Iris.Option.opM_opM_assoc | |
| cmra_opM_proper | Derived from nonexpansivity | |
| cmra_op_discrete | Iris.CMRA.discrete_op | |
| cmra_op_ne | Iris.CMRA.op_ne' | |
| cmra_op_ne' | Iris.CMRA.cmra_op_ne2 | |
| cmra_op_opM_assoc | Iris.CMRA.op_opM_assoc | |
| cmra_op_opM_assoc_L | Iris.CMRA.op_opM_assoc_L | |
| cmra_op_proper' | Iris.CMRA.op_eqv | |
| cmra_pcore_core | Iris.CMRA.pcore_eq_core | |
| cmra_pcore_core_id | Iris.CMRA.CoreId.of_pcore_eq_some | |
| cmra_pcore_dup | Iris.CMRA.pcore_op_self | |
| cmra_pcore_dup' | Iris.CMRA.pcore_op_self' | |
| cmra_pcore_dup_L | Iris.CMRA.pcore_op_self_L | |
| cmra_pcore_idemp | Iris.CMRA.pcore_idemp | |
| cmra_pcore_idemp' | Iris.CMRA.pcore_idem' | |
| cmra_pcore_idemp_L | Iris.CMRA.pcore_idem_L | |
| cmra_pcore_l | Iris.CMRA.pcore_l | |
| cmra_pcore_l' | Iris.CMRA.pcore_op_left' | |
| cmra_pcore_l_L | Iris.CMRA.pcore_op_left_L | |
| cmra_pcore_mono | Iris.CMRA.pcore_mono | |
| cmra_pcore_mono' | Iris.CMRA.pcore_mono' | |
| cmra_pcore_monoN' | Iris.CMRA.pcore_monoN' | |
| cmra_pcore_ne | Iris.CMRA.pcore_ne' | |
| cmra_pcore_ne' | Iris.CMRA.instNonExpansiveOptionPcore | |
| cmra_pcore_proper | Iris.CMRA.pcore_proper | |
| cmra_pcore_proper' | Iris.CMRA.pcore_proper' | |
| cmra_pcore_r | Iris.CMRA.pcore_op_right | |
| cmra_pcore_r' | Iris.CMRA.pcore_op_right' | |
| cmra_pcore_r_L | Iris.CMRA.pcore_op_right_L | |
| cmra_pcore_valid | Iris.CMRA.pcore_valid | |
| cmra_pcore_validN | Iris.CMRA.pcore_validN | |
| cmra_total_mixin | Use CMRA + IsTotal | |
| cmra_unit_cmra_total | Iris.CMRA.unit_total | |
| cmra_validN_Some_includedN | Iris.Option.validN_of_incN_validN | |
| cmra_validN_included | Iris.CMRA.validN_of_inc | |
| cmra_validN_includedN | Iris.CMRA.validN_of_incN | |
| cmra_validN_le | Iris.CMRA.validN_of_le | |
| cmra_validN_lt | Iris.CMRA.validN_of_lt | |
| cmra_validN_ne | Iris.CMRA.validN_ne' | |
| cmra_validN_ne' | Iris.CMRA.validN_dist_iff | |
| cmra_validN_op_l | Iris.CMRA.validN_op_l | |
| cmra_validN_op_r | Iris.CMRA.validN_op_right | |
| cmra_validN_proper | Iris.CMRA.validN_eqv_iff | |
| cmra_valid_Some_included | Iris.Option.valid_of_inc_valid | |
| cmra_valid_included | Iris.CMRA.valid_of_inc | |
| cmra_valid_op_l | Iris.CMRA.valid_op_left | |
| cmra_valid_op_r | Iris.CMRA.valid_op_right | |
| cmra_valid_proper | Iris.CMRA.valid_iff | |
| cmra_valid_validN | Iris.CMRA.valid_validN | |
| constRF | Iris.COFE.OFunctor.constOF_RFunctor | |
| constRF_contractive | Iris.OFunctor.constOF_RFunctorContractive | |
| core | Iris.CMRA.core | |
| core_id_core | Iris.CMRA.core_eqv_self | |
| core_id_core_L | Iris.CMRA.core_eq_self | |
| core_id_dup | Iris.CMRA.op_self | |
| core_id_dup_L | Iris.CMRA.core_id_dup_L | |
| core_id_extract | Iris.CMRA.op_core_right_of_inc | |
| core_id_total | Iris.CMRA.coreId_iff_core_eqv_self | |
| core_id_total_L | Iris.CMRA.coreId_iff_core_eq_self | |
| discrete_cancelable | Iris.CMRA.discrete_cancelable | |
| discrete_cmra_discrete | Folded into Lean's CMRA.Discrete typeclass | |
| discrete_cmra_mixin | Lean uses the CMRA + CMRA.Discrete typeclasses directly. | |
| discrete_funR | Iris.cmraDiscreteFunO | |
| discrete_funUR | Iris.ucmraDiscreteFunO | |
| discrete_funURF | Iris.urFunctorDiscreteFunOF | |
| discrete_funURF_contractive | Iris.DiscreteFunOF_URFC | |
| discrete_fun_cmra_mixin | Use CMRA instance | |
| discrete_fun_op_instance | Use CMRA instance | |
| discrete_fun_pcore_instance | Use CMRA instance | |
| discrete_fun_ucmra_mixin | Use UCMRA instance | |
| discrete_fun_unit_instance | Use UCMRA instance | |
| discrete_fun_validN_instance | Use CMRA instance | |
| discrete_fun_valid_instance | Use CMRA instance | |
| discrete_id_free | Iris.CMRA.discrete_id_free | |
| discrete_validN_instance | Use CMRA instance | |
| empty_cancelable | Iris.CMRA.empty_cancelable | |
| exclusiveN_Some_l | Iris.Option.exclusiveN_some_left | |
| exclusiveN_Some_r | Iris.Option.exclusiveN_some_right | |
| exclusiveN_l | Iris.CMRA.not_valid_exclN_op_left | |
| exclusiveN_opM | Iris.CMRA.none_of_excl_valid_op | |
| exclusiveN_r | Iris.CMRA.not_valid_exclN_op_right | |
| exclusive_Some_l | Iris.Option.exclusive_some_left | |
| exclusive_Some_r | Iris.Option.exclusive_some_right | |
| exclusive_cancelable | Iris.CMRA.exclusive_cancelable | |
| exclusive_id_free | Iris.CMRA.exclusive_idFree | |
| exclusive_included | Iris.CMRA.not_valid_of_excl_inc | |
| exclusive_includedN | Iris.CMRA.not_valid_of_exclN_inc | |
| exclusive_l | Iris.CMRA.not_valid_excl_op_left | |
| exclusive_r | Iris.CMRA.not_excl_op_right | |
| id_freeN_l | Iris.CMRA.id_freeN_l | |
| id_freeN_r | Iris.CMRA.id_freeN_r | |
| id_free_l | Iris.CMRA.id_free_l | |
| id_free_op_l | Iris.CMRA.idFree_op_l | |
| id_free_op_r | Iris.CMRA.idFree_op_r | |
| id_free_proper | Iris.CMRA.idFree_iff | |
| id_free_r | Iris.CMRA.id_free_r | |
| included | Iris.CMRA.Included | |
| includedN | Iris.CMRA.IncludedN | |
| opM | Iris.CMRA.op? | |
| op_None | Iris.Option.op_none_iff | |
| op_None_left_id | Iris.Option.op_none_left_id | |
| op_None_right_id | Iris.Option.op_none_right_id | |
| op_is_Some | Iris.Option.op_isSome | |
| optionR | Iris.cmraOption | |
| optionUR | Iris.ucmraOption | |
| optionURF | Iris.urFunctorOptionOF | |
| optionURF_contractive | Iris.urFunctorContractiveOptionOF | |
| option_cancelable | Iris.Option.instCancelableOptionOfIdFree | |
| option_cmra_discrete | Iris.Option.instDiscreteOption | |
| option_cmra_mixin | Iris.cmraOption | |
| option_core_id | Iris.Option.option_core_id | |
| option_included | Iris.Option.inc_iff | |
| option_includedN | Iris.Option.incN_iff | |
| option_includedN_total | Iris.Option.incN_iff_is_total | |
| option_included_total | Iris.Option.inc_iff_isTotal | |
| option_op_instance | Use CMRA instance | |
| option_pcore_instance | Use CMRA instance | |
| option_ucmra_mixin | Use UCMRA instance | |
| option_unit_instance | Use UCMRA instance | |
| option_validN_instance | Use CMRA instance | |
| option_valid_instance | Use CMRA instance | |
| pair_includedN | Iris.Prod.incN_iff | |
| pcore_Some | Iris.Option.pcore_some | |
| prodR | Iris.Prod.cmraProd | |
| prodRF | Iris.instRFunctorProdOF | |
| prodRF_contractive | Iris.instRFunctorContractiveProdOF | |
| prod_cmra_discrete | Iris.Prod.instDiscreteProd | |
| prod_cmra_mixin | Iris.Prod.cmraProd | |
| prod_map_cmra_morphism | Iris.Prod.mapC | |
| prod_op_instance | Use CMRA instance | |
| prod_pcore_instance | Use CMRA instance | |
| prod_validN_instance | Use CMRA instance | |
| prod_valid_instance | Use CMRA instance | |
| rFunctor | Iris.RFunctor | |
| rFunctorContractive | Iris.RFunctorContractive | |
| rFunctor_to_oFunctor | Iris.RFunctor.toOFunctor | |
| rFunctor_to_oFunctor_contractive | Iris.RFunctorContractive.toOFunctorContractive | |
| ucmra | Iris.UCMRA | |
| ucmra_cmraR | Folded into Lean's UCMRA extends CMRA. | |
| ucmra_ofeO | Folded into Lean's UCMRA → OFE. | |
| ucmra_pcore_unit | Iris.CMRA.ucmra_pcore_unit | |
| ucmra_unit_core_id | Iris.CMRA.unit_CoreId | |
| ucmra_unit_least | Iris.CMRA.inc_unit | |
| ucmra_unit_leastN | Iris.CMRA.incN_unit | |
| ucmra_unit_left_id | Iris.CMRA.ucmra_unit_left_id | |
| ucmra_unit_left_id_L | Iris.CMRA.unit_left_id_L | |
| ucmra_unit_right_id | Iris.CMRA.unit_right_id | |
| ucmra_unit_right_id_L | Iris.CMRA.unit_right_id_L | |
| ucmra_unit_valid | Iris.CMRA.ucmra_unit_valid | |
| ucmra_unit_validN | Iris.CMRA.unit_validN | |
| unitR | Iris.cmraUnit | |
| unit_cancelable | Subsumed by empty_cancelable | |
| unit_cmra_mixin | Iris.cmraUnit | |
| unit_core_id | Subsumed by unit_CoreId | |
| unit_op_instance | Use CMRA instance | |
| unit_pcore_instance | Use CMRA instance | |
| unit_validN_instance | Use CMRA instance | |
| unit_valid_instance | Use CMRA instance | |
| urFunctor | Iris.URFunctor | |
| urFunctorContractive | Iris.URFunctorContractive | |
| urFunctor_to_rFunctor | Iris.URFunctor.toRFunctor | |
| urFunctor_to_rFunctor_contractive | Iris.URFunctorContractive.toRFunctorContractive |
| Rocq Name | Status | Details |
|---|---|---|
| big_opL_None | ||
| big_opMS_None | ||
| big_opM_None | ||
| big_opS_None |
| Rocq Name | Status | Details |
|---|---|---|
| coPsetO | ||
| coPsetR | ||
| coPsetUR | ||
| coPset_cmra_discrete | ||
| coPset_core | ||
| coPset_disj | ||
| coPset_disjO | ||
| coPset_disjR | ||
| coPset_disjUR | ||
| coPset_disj_cmra_discrete | ||
| coPset_disj_included | ||
| coPset_disj_op_instance | ||
| coPset_disj_pcore_instance | ||
| coPset_disj_ra_mixin | ||
| coPset_disj_ucmra_mixin | ||
| coPset_disj_union | ||
| coPset_disj_unit_instance | ||
| coPset_disj_valid_instance | ||
| coPset_disj_valid_inv_l | ||
| coPset_disj_valid_op | ||
| coPset_included | ||
| coPset_local_update | ||
| coPset_op | ||
| coPset_opM | ||
| coPset_op_instance | ||
| coPset_pcore_instance | ||
| coPset_ra_mixin | ||
| coPset_ucmra_mixin | ||
| coPset_unit_instance | ||
| coPset_update | ||
| coPset_valid_instance |
| Rocq Name | Status | Details |
|---|---|---|
| solver.embed' | ||
| solver.ff_ff | ||
| solver.g_embed_coerce | ||
| solver.gg_gg | ||
| solution | Use OFE.iso + Inhabited + COFE. | |
| solver.A' | Iris.COFE.OFunctor.Fix.Impl.A' | |
| solver.A_cofe | Inference succeeds automatically via `instA`/`instA'` | |
| solver.T | Iris.COFE.OFunctor.Fix.Impl.instOFETower | |
| solver.coerce | Iris.COFE.OFunctor.Fix.Impl.eqToHom | |
| solver.coerce_f | Iris.COFE.OFunctor.Fix.Impl.eqToHom_up | |
| solver.coerce_id | Not needed | |
| solver.coerce_proper | Inlined in embed | |
| solver.embed | Iris.COFE.OFunctor.Fix.Impl.Tower.embed | |
| solver.embed_coerce | Iris.COFE.OFunctor.Fix.Impl.embed | |
| solver.embed_f | Iris.COFE.OFunctor.Fix.Impl.Tower.embed_up | |
| solver.embed_ne | Implicit in embed | |
| solver.embed_tower | Iris.COFE.OFunctor.Fix.Impl.Tower.embed_self | |
| solver.f | Iris.COFE.OFunctor.Fix.Impl.up | |
| solver.f_S | Not needed | |
| solver.f_tower | Iris.COFE.OFunctor.Fix.Impl.Tower.up | |
| solver.ff | Iris.COFE.OFunctor.Fix.Impl.upN | |
| solver.ff_tower | Iris.COFE.OFunctor.Fix.Impl.Tower.upN | |
| solver.fg | Iris.COFE.OFunctor.Fix.Impl.up_down | |
| solver.fold | Iris.COFE.OFunctor.Fix.fold | |
| solver.fold_ne | Implicit in the OFE.Iso structure | |
| solver.g_S | Not needed | |
| solver.g_coerce | Iris.COFE.OFunctor.Fix.Impl.down_eqToHom | |
| solver.gf | Iris.COFE.OFunctor.Fix.Impl.down_up | |
| solver.gg | Iris.COFE.OFunctor.Fix.Impl.downN | |
| solver.gg_tower | Iris.COFE.OFunctor.Fix.Impl.Tower.downN | |
| solver.ggff | Iris.COFE.OFunctor.Fix.Impl.downN_upN | |
| solver.project | Iris.COFE.OFunctor.Fix.Impl.Tower.proj | |
| solver.result | Use `Fix F` with Inhabited + COFE instances and Fix.iso | |
| solver.tower | Iris.COFE.OFunctor.Fix.Impl.Tower | |
| solver.tower_car_ne | Use NonExpansive instance | |
| solver.tower_chain | Iris.COFE.OFunctor.Fix.Impl.towerChain | |
| solver.tower_cofe | Use IsCOFE instance | |
| solver.tower_compl | Use IsCOFE instance | |
| solver.tower_dist | Included in OFE (Tower F) instance | |
| solver.tower_equiv | Included in OFE (Tower F) instance | |
| solver.tower_inhabited | Implicit in Lean's Inhabited (Tower F) instance | |
| solver.tower_ofe_mixin | Not needed | |
| solver.unfold | Iris.COFE.OFunctor.Fix.unfold | |
| solver.unfold_chain | Iris.COFE.OFunctor.Fix.Impl.unfoldChain | |
| solver.unfold_ne | Implicit in the OFE.Iso structure |
| Rocq Name | Status | Details |
|---|---|---|
| csum_bchain_l | ||
| csum_bchain_r | ||
| csum_lbcompl | ||
| maybe_Cinl | ||
| maybe_Cinr | ||
| Cinl_cancelable | Iris.Csum.instCancelableInl | |
| Cinl_core_id | Iris.Csum.instCoreIdInl | |
| Cinl_discrete | Iris.Csum.instDiscreteEInl | |
| Cinl_exclusive | Iris.Csum.instExclusiveInl | |
| Cinl_id_free | Iris.Csum.instIdFreeInl | |
| Cinl_included | Iris.Csum.inl_included | |
| Cinl_inj | Iris.Csum.inl_inj | |
| Cinl_inj_dist | Iris.Csum.inl_injN | |
| Cinl_ne | Iris.Csum.instNonExpansiveInl | |
| Cinl_op | Iris.Csum.inl_op | |
| Cinl_proper | Derivable using NonExpansive.eqv | |
| Cinl_valid | Iris.Csum.inl_valid | |
| Cinr_cancelable | Iris.Csum.instCancelableInr | |
| Cinr_core_id | Iris.Csum.instCoreIdInr | |
| Cinr_discrete | Iris.Csum.instDiscreteEInr | |
| Cinr_exclusive | Iris.Csum.instExclusiveInr | |
| Cinr_id_free | Iris.Csum.instIdFreeInr | |
| Cinr_included | Iris.Csum.inr_included | |
| Cinr_inj | Iris.Csum.inr_inj | |
| Cinr_inj_dist | Iris.Csum.inr_injN | |
| Cinr_ne | Iris.Csum.instNonExpansiveInr | |
| Cinr_op | Iris.Csum.inr_op | |
| Cinr_proper | Derivable using NonExpansive.eqv | |
| Cinr_valid | Iris.Csum.inr_valid | |
| CsumInvalid_included | Iris.Csum.invalid_included | |
| Some_csum_included | Iris.Csum.some_included | |
| Some_csum_includedN | Iris.Csum.some_includedN | |
| csum | Iris.Csum | |
| csumO | Iris.Csum.instOFE | |
| csumO_map | Iris.Csum.oMap | |
| csumO_map_ne | Iris.Csum.oMap_ne | |
| csumR | Use Csum type with typeclass inference | |
| csumRF | Iris.Csum.OF | |
| csumRF_contractive | Iris.Csum.instRFunctorContractiveOF | |
| csum_chain_l | Iris.Csum.chainL | |
| csum_chain_r | Iris.Csum.chainR | |
| csum_cmra_discrete | Iris.Csum.instDiscrete_1 | |
| csum_cmra_mixin | Iris.Csum.instCMRA | |
| csum_cofe | Iris.Csum.instIsCOFE | |
| csum_compl | Included in IsCOFE instance | |
| csum_dist | Iris.Csum.Dist | |
| csum_equiv | Iris.Csum.Equiv | |
| csum_included | Iris.Csum.included | |
| csum_includedN | Iris.Csum.includedN | |
| csum_leibniz | Iris.Csum.instLeibniz | |
| csum_local_update_l | Iris.Csum.local_update_l | |
| csum_local_update_r | Iris.Csum.local_update_r | |
| csum_map | Iris.Csum.map | |
| csum_map_cmra_morphism | Iris.Csum.cMap | |
| csum_map_cmra_ne | Iris.Csum.map_ne | |
| csum_map_compose | Iris.Csum.map_compose | |
| csum_map_ext | Iris.Csum.map_ext | |
| csum_map_id | Iris.Csum.map_id | |
| csum_ofe_discrete | Iris.Csum.instDiscrete | |
| csum_ofe_mixin | Not needed | |
| csum_op_instance | Use CMRA instance | |
| csum_pcore_instance | Use CMRA instance | |
| csum_updateP'_l | Iris.Csum.updateP'_l | |
| csum_updateP'_r | Iris.Csum.updateP'_r | |
| csum_updateP_l | Iris.Csum.updateP_l | |
| csum_updateP_r | Iris.Csum.updateP_r | |
| csum_update_l | Iris.Csum.update_l | |
| csum_update_r | Iris.Csum.update_r | |
| csum_validN_instance | Use CMRA instance | |
| csum_valid_instance | Use CMRA instance |
| Rocq Name | Status | Details |
|---|---|---|
| dfrac_countable | ||
| dfrac_eq_dec | ||
| DfracBoth_inj | Not needed | |
| DfracOwn_inj | Not needed | |
| dfrac | Iris.DFrac | |
| dfracO | Use DFrac type with typeclass inference | |
| dfracR | Iris.DFrac.instCMRADFrac | |
| dfrac_cancelable | Iris.DFrac.instCancelableOwn | |
| dfrac_cmra_discrete | Iris.DFrac.instDiscrete | |
| dfrac_discard_update | Iris.DFrac.DFrac.update_discard | |
| dfrac_discarded_core_id | Iris.DFrac.instCoreIdDiscard | |
| dfrac_discarded_included | Iris.DFrac.discard_included | |
| dfrac_full_exclusive | Iris.DFrac.own_whole_exclusive | |
| dfrac_inhabited | Iris.DFrac.instInhabited | |
| dfrac_is_op | Iris.DFrac.isOp_dfrac_own | |
| dfrac_op_discarded | Iris.DFrac.op_discard | |
| dfrac_op_instance | Use CMRA instance | |
| dfrac_op_own | Iris.DFrac.op_own | |
| dfrac_own_id_free | Iris.DFrac.instIdFreeOwn | |
| dfrac_own_included | Iris.DFrac.own_included | |
| dfrac_pcore_instance | Use CMRA instance | |
| dfrac_ra_mixin | Not needed | |
| dfrac_undiscard_update | Iris.DFrac.DFrac.update_acquire | |
| dfrac_valid | Iris.DFrac.valid_iff | |
| dfrac_valid_discarded | Iris.DFrac.valid_discard | |
| dfrac_valid_instance | Use CMRA instance | |
| dfrac_valid_own | Iris.DFrac.valid_own | |
| dfrac_valid_own_1 | Iris.DFrac.valid_own_one | |
| dfrac_valid_own_discarded | Iris.DFrac.valid_own_op_discard | |
| dfrac_valid_own_l | Iris.DFrac.valid_own_op | |
| dfrac_valid_own_r | Iris.DFrac.valid_op_own |
| Rocq Name | Status | Details |
|---|---|---|
| DynReservationMap_discrete | ||
| DynReservationMap_ne | ||
| DynReservationMap_proper | ||
| dyn_reservation_map | ||
| dyn_reservation_mapO | ||
| dyn_reservation_mapR | ||
| dyn_reservation_mapUR | ||
| dyn_reservation_map_alloc | ||
| dyn_reservation_map_cmra_discrete | ||
| dyn_reservation_map_cmra_mixin | ||
| dyn_reservation_map_data | ||
| dyn_reservation_map_data_core_id | ||
| dyn_reservation_map_data_discrete | ||
| dyn_reservation_map_data_is_op | ||
| dyn_reservation_map_data_mono | ||
| dyn_reservation_map_data_ne | ||
| dyn_reservation_map_data_op | ||
| dyn_reservation_map_data_proj_ne | ||
| dyn_reservation_map_data_proj_proper | ||
| dyn_reservation_map_data_proj_validN | ||
| dyn_reservation_map_data_proper | ||
| dyn_reservation_map_data_valid | ||
| dyn_reservation_map_dist | ||
| dyn_reservation_map_empty_instance | ||
| dyn_reservation_map_equiv | ||
| dyn_reservation_map_included | ||
| dyn_reservation_map_ofe_discrete | ||
| dyn_reservation_map_ofe_mixin | ||
| dyn_reservation_map_op_instance | ||
| dyn_reservation_map_pcore_instance | ||
| dyn_reservation_map_reserve | ||
| dyn_reservation_map_reserve' | ||
| dyn_reservation_map_token | ||
| dyn_reservation_map_token_difference | ||
| dyn_reservation_map_token_discrete | ||
| dyn_reservation_map_token_proj_validN | ||
| dyn_reservation_map_token_union | ||
| dyn_reservation_map_token_valid | ||
| dyn_reservation_map_token_valid_op | ||
| dyn_reservation_map_ucmra_mixin | ||
| dyn_reservation_map_update | ||
| dyn_reservation_map_updateP | ||
| dyn_reservation_map_validN_eq | ||
| dyn_reservation_map_validN_instance | ||
| dyn_reservation_map_valid_eq | ||
| dyn_reservation_map_valid_instance | ||
| from_reservation_map | ||
| to_reservation_map |
| Rocq Name | Status | Details |
|---|---|---|
| maybe_Excl | ||
| ExclInvalid_discrete | Iris.Excl.instDiscreteEInvalid | |
| ExclInvalid_included | Iris.Excl.invalid_inc | |
| Excl_discrete | Iris.Excl.instDiscreteEExcl | |
| Excl_dist_inj | Iris.Excl.excl_dist_inj | |
| Excl_included | Iris.Excl.excl_included | |
| Excl_includedN | Iris.Excl.excl_includedN | |
| Excl_inj | Iris.Excl.excl_inj | |
| Excl_ne | Iris.Excl.instNonExpansiveExcl | |
| Excl_proper | Derivable from NonExpansive.eqv | |
| excl | Iris.Excl | |
| exclO | Iris.Excl.instOFE | |
| exclO_map | Iris.Excl.oMap | |
| exclO_map_ne | Iris.Excl.oMap_ne | |
| exclR | Iris.Excl.instCMRAOfOFE | |
| exclRF | Iris.Excl.ExclOF | |
| exclRF_contractive | Iris.Excl.instRFunctorContractiveExclOFOfOFunctorContractive | |
| excl_cmra_discrete | Iris.Excl.instDiscreteOfDiscrete | |
| excl_cmra_mixin | Not needed | |
| excl_cofe | Iris.Excl.instIsCOFE | |
| excl_dist | Iris.Excl.Dist | |
| excl_equiv | Iris.Excl.Equiv | |
| excl_exclusive | Iris.Excl.instExclusive | |
| excl_included | Iris.Excl.inc_iff | |
| excl_includedN | Iris.Excl.incN_iff | |
| excl_leibniz | Iris.Excl.instLeibniz | |
| excl_map | Iris.Excl.map | |
| excl_map_cmra_morphism | Iris.Excl.hom | |
| excl_map_compose | Iris.Excl.map_comp | |
| excl_map_ext | Iris.Excl.map_ext | |
| excl_map_id | Iris.Excl.map_id | |
| excl_map_ne | Iris.Excl.map_ne | |
| excl_ofe_discrete | Iris.Excl.instDiscrete | |
| excl_ofe_mixin | Not needed | |
| excl_op_instance | Use CMRA instance | |
| excl_pcore_instance | Use CMRA instance | |
| excl_validN_instance | Use CMRA instance | |
| excl_validN_inv_l | Iris.Excl.validN_inv_some_l | |
| excl_validN_inv_r | Iris.Excl.validN_inv_some_r | |
| excl_valid_instance | Use CMRA instance |
| Rocq Name | Status | Details |
|---|---|---|
| fracO | Iris.Qp | |
| fracR | Iris.Qp | |
| frac_cancelable | Iris.instCancelableQp | |
| frac_cmra_discrete | Iris.instDiscreteQp | |
| frac_full_exclusive | Iris.instExclusiveQp1 | |
| frac_id_free | Iris.instIdFreeQp | |
| frac_included | Iris.Frac.inc_iff | |
| frac_included_weak | Iris.Frac.le_of_inc | |
| frac_is_op | Iris.instIsOpMergeQpHAdd | |
| frac_op | Iris.Frac.op_eq | |
| frac_op_instance | Use CMRA instance | |
| frac_pcore_instance | Use CMRA instance | |
| frac_ra_mixin | Use CMRA instance | |
| frac_valid | Iris.Frac.valid_iff | |
| frac_valid_1 | Iris.Qp.valid_one | |
| frac_valid_instance | Use CMRA instance | |
| is_op_frac | Iris.instIsOpQpHalf |
| Rocq Name | Status | Details |
|---|---|---|
| discrete_funO_ofe_discrete | ||
| discrete_funR_cmra_discrete | ||
| discrete_fun_insert | ||
| discrete_fun_insert_discrete | ||
| discrete_fun_insert_ne | ||
| discrete_fun_insert_proper | ||
| discrete_fun_insert_update | ||
| discrete_fun_insert_updateP | ||
| discrete_fun_insert_updateP' | ||
| discrete_fun_lookup_insert | ||
| discrete_fun_lookup_insert_ne | ||
| discrete_fun_lookup_singleton | ||
| discrete_fun_lookup_singleton_ne | ||
| discrete_fun_singleton | ||
| discrete_fun_singleton_core | ||
| discrete_fun_singleton_core_id | ||
| discrete_fun_singleton_discrete | ||
| discrete_fun_singleton_ne | ||
| discrete_fun_singleton_op | ||
| discrete_fun_singleton_proper | ||
| discrete_fun_singleton_unit | ||
| discrete_fun_singleton_update | ||
| discrete_fun_singleton_updateP | ||
| discrete_fun_singleton_updateP' | ||
| discrete_fun_singleton_updateP_empty | ||
| discrete_fun_singleton_updateP_empty' | ||
| discrete_fun_singleton_update_empty | ||
| discrete_fun_singleton_valid | ||
| discrete_fun_singleton_validN | ||
| discrete_fun_update | ||
| discrete_fun_updateP | ||
| discrete_fun_updateP' |
| Rocq Name | Status | Details |
|---|---|---|
| alloc_local_update | ||
| alloc_singleton_local_update | ||
| alloc_unit_singleton_update | ||
| alloc_unit_singleton_updateP | ||
| alloc_unit_singleton_updateP' | ||
| alloc_updateP | ||
| alloc_updateP' | ||
| alloc_updateP_cofinite | ||
| alloc_updateP_cofinite' | ||
| alloc_updateP_strong | ||
| alloc_updateP_strong' | ||
| alloc_updateP_strong_dep | ||
| alloc_updateP_strong_dep' | ||
| alter_ne | ||
| big_opM_ne_2 | ||
| big_opM_singletons | ||
| big_opS_gset_to_gmap | ||
| big_opS_gset_to_gmap_L | ||
| delete_local_update | ||
| delete_local_update_cancelable | ||
| delete_ne | ||
| delete_singleton_local_update | ||
| delete_singleton_local_update_cancelable | ||
| delete_update | ||
| delete_valid | ||
| delete_validN | ||
| dom_included | ||
| dom_op | ||
| gmapO | ||
| gmapOF | ||
| gmapOF_contractive | ||
| gmapO_leibniz | ||
| gmapO_map | ||
| gmapO_map_ne | ||
| gmapR | ||
| gmapRF | ||
| gmapRF_contractive | ||
| gmapUR | ||
| gmapURF | ||
| gmapURF_contractive | ||
| gmap_bchain | ||
| gmap_cancelable | ||
| gmap_chain | ||
| gmap_cmra_discrete | ||
| gmap_cmra_mixin | ||
| gmap_cofe | ||
| gmap_compl | ||
| gmap_core_id | ||
| gmap_core_id' | ||
| gmap_disjoint_ne | ||
| gmap_dist | ||
| gmap_dom_ne | ||
| gmap_empty_discrete | ||
| gmap_fmap_cmra_morphism | ||
| gmap_fmap_mono | ||
| gmap_fmap_ne | ||
| gmap_fmap_ne_ext | ||
| gmap_insert_discrete | ||
| gmap_lbcompl | ||
| gmap_local_update | ||
| gmap_lookup_discrete | ||
| gmap_ofe_discrete | ||
| gmap_ofe_mixin | ||
| gmap_op | ||
| gmap_op_empty_l_L | ||
| gmap_op_empty_r | ||
| gmap_op_instance | ||
| gmap_op_union | ||
| gmap_op_valid0_disjoint | ||
| gmap_op_valid_disjoint | ||
| gmap_pcore_instance | ||
| gmap_singleton_core_id | ||
| gmap_singleton_discrete | ||
| gmap_ucmra_mixin | ||
| gmap_union_dist_eq | ||
| gmap_union_ne | ||
| gmap_unit_instance | ||
| gmap_validN_instance | ||
| gmap_valid_instance | ||
| insert_alloc_local_update | ||
| insert_idN | ||
| insert_local_update | ||
| insert_ne | ||
| insert_op | ||
| insert_singleton_op | ||
| insert_update | ||
| insert_updateP | ||
| insert_updateP' | ||
| insert_valid | ||
| insert_validN | ||
| lookup_core | ||
| lookup_included | ||
| lookup_includedN | ||
| lookup_ne | ||
| lookup_op | ||
| lookup_opM | ||
| lookup_op_homomorphism | ||
| lookup_total_ne | ||
| lookup_validN_Some | ||
| lookup_valid_Some | ||
| map_fmap_ne | ||
| map_seq_ne | ||
| map_zip_with_ne | ||
| merge_ne | ||
| partial_alter_ne | ||
| singleton_cancelable | ||
| singleton_core | ||
| singleton_core' | ||
| singleton_core_total | ||
| singleton_included | ||
| singleton_includedN_l | ||
| singleton_included_exclusive_l | ||
| singleton_included_l | ||
| singleton_included_mono | ||
| singleton_included_total | ||
| singleton_is_op | ||
| singleton_local_update | ||
| singleton_local_update_any | ||
| singleton_ne | ||
| singleton_op | ||
| singleton_update | ||
| singleton_updateP | ||
| singleton_updateP' | ||
| singleton_valid | ||
| singleton_validN | ||
| union_with_ne |
| Rocq Name | Status | Details |
|---|---|---|
| big_opMS_singletons | ||
| gmultisetO | ||
| gmultisetR | ||
| gmultisetUR | ||
| gmultiset_cancelable | ||
| gmultiset_cmra_discrete | ||
| gmultiset_core | ||
| gmultiset_included | ||
| gmultiset_local_update | ||
| gmultiset_local_update_alloc | ||
| gmultiset_local_update_dealloc | ||
| gmultiset_op | ||
| gmultiset_opM | ||
| gmultiset_op_instance | ||
| gmultiset_pcore_instance | ||
| gmultiset_ra_mixin | ||
| gmultiset_ucmra_mixin | ||
| gmultiset_unit_instance | ||
| gmultiset_update | ||
| gmultiset_validN_instance | ||
| gmultiset_valid_instance |
| Rocq Name | Status | Details |
|---|---|---|
| GSet_inj | ||
| big_opS_singletons | ||
| gsetO | ||
| gsetR | ||
| gsetUR | ||
| gset_cmra_discrete | ||
| gset_core | ||
| gset_core_id | ||
| gset_disj | ||
| gset_disjO | ||
| gset_disjR | ||
| gset_disjUR | ||
| gset_disj_alloc_empty_local_update | ||
| gset_disj_alloc_empty_updateP | ||
| gset_disj_alloc_empty_updateP' | ||
| gset_disj_alloc_empty_updateP_strong | ||
| gset_disj_alloc_empty_updateP_strong' | ||
| gset_disj_alloc_local_update | ||
| gset_disj_alloc_op_local_update | ||
| gset_disj_alloc_updateP | ||
| gset_disj_alloc_updateP' | ||
| gset_disj_alloc_updateP_strong | ||
| gset_disj_alloc_updateP_strong' | ||
| gset_disj_cmra_discrete | ||
| gset_disj_dealloc_empty_local_update | ||
| gset_disj_dealloc_local_update | ||
| gset_disj_dealloc_op_local_update | ||
| gset_disj_included | ||
| gset_disj_op_instance | ||
| gset_disj_pcore_instance | ||
| gset_disj_ra_mixin | ||
| gset_disj_ucmra_mixin | ||
| gset_disj_union | ||
| gset_disj_unit_instance | ||
| gset_disj_valid_instance | ||
| gset_disj_valid_inv_l | ||
| gset_disj_valid_op | ||
| gset_included | ||
| gset_local_update | ||
| gset_op | ||
| gset_opM | ||
| gset_op_instance | ||
| gset_pcore_instance | ||
| gset_ra_mixin | ||
| gset_ucmra_mixin | ||
| gset_unit_instance | ||
| gset_update | ||
| gset_valid_instance | ||
| set_unfold_gset_disj_included | ||
| set_unfold_gset_disj_valid_op | ||
| set_unfold_gset_eq | ||
| set_unfold_gset_included |
| Rocq Name | Status | Details |
|---|---|---|
| dfrac_agreeRF_contractive | ||
| dfrac_agreeR | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.DFracAgreeR | |
| dfrac_agreeRF | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.DFracAgreeRF | |
| dfrac_agree_included | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.included | |
| dfrac_agree_includedN | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.includedN | |
| dfrac_agree_included_L | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.included_L | |
| dfrac_agree_op | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.mk_op | |
| dfrac_agree_op_valid | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.op_valid | |
| dfrac_agree_op_validN | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.op_validN | |
| dfrac_agree_op_valid_L | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.op_valid_L | |
| dfrac_agree_persist | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.persist | |
| dfrac_agree_unpersist | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.unpersist | |
| dfrac_agree_update_2 | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.update₂ | |
| frac_agree_included | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.Frac.included | |
| frac_agree_includedN | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.Frac.includedN | |
| frac_agree_included_L | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.Frac.included_L | |
| frac_agree_op | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.Frac.mk_op | |
| frac_agree_op_valid | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.Frac.op_valid | |
| frac_agree_op_validN | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.Frac.op_validN | |
| frac_agree_op_valid_L | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.Frac.op_valid_L | |
| frac_agree_update_2 | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.Frac.update₂ | |
| to_dfrac_agree | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.mk | |
| to_dfrac_agree_discrete | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.mk_discrete | |
| to_dfrac_agree_exclusive | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.mk_exclusive | |
| to_dfrac_agree_inj | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.mk_inj | |
| to_dfrac_agree_injN | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.mk_injN | |
| to_dfrac_agree_ne | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.mk_ne | |
| to_dfrac_agree_proper | Derivable from mk_ne with NonExpansive.eqv | |
| to_frac_agree | _private.Iris.Algebra.Lib.DFracAgree.0.Iris.DFracAgree.Frac.mk |
| Rocq Name | Status | Details |
|---|---|---|
| excl_authRF_contractive | ||
| excl_authURF_contractive | ||
| excl_authR | Iris.ExclAuth.ExclAuthR | |
| excl_authRF | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.ExclAuthRF | |
| excl_authUR | Iris.ExclAuth.ExclAuthUR | |
| excl_authURF | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.ExclAuthURF | |
| excl_auth_agree | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.agree | |
| excl_auth_agreeN | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.agreeN | |
| excl_auth_agree_L | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.agree_L | |
| excl_auth_auth | Iris.ExclAuth.auth | |
| excl_auth_auth_discrete | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.auth_discrete | |
| excl_auth_auth_ne | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.auth_ne | |
| excl_auth_auth_op_valid | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.auth_op_valid | |
| excl_auth_auth_op_validN | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.auth_op_validN | |
| excl_auth_auth_proper | Derivable from auth_ne with NonExpansive.eqv | |
| excl_auth_frag | Iris.ExclAuth.frag | |
| excl_auth_frag_discrete | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.frag_discrete | |
| excl_auth_frag_ne | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.frag_ne | |
| excl_auth_frag_op_valid | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.frag_op_valid | |
| excl_auth_frag_op_validN | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.frag_op_validN | |
| excl_auth_frag_proper | Derivable from frag_ne with NonExpansive.eqv | |
| excl_auth_update | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.update | |
| excl_auth_valid | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.valid | |
| excl_auth_validN | _private.Iris.Algebra.Lib.ExclAuth.0.Iris.ExclAuth.validN |
| Rocq Name | Status | Details |
|---|---|---|
| frac_authRF_contractive | ||
| frac_authURF_contractive | ||
| frac_authR | FracAuth | |
| frac_authRF | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.FracAuthF | |
| frac_authUR | FracAuth | |
| frac_authURF | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.FracAuthURF | |
| frac_auth_agree | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.agree | |
| frac_auth_agreeN | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.agreeN | |
| frac_auth_agree_L | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.agree_L | |
| frac_auth_auth | FracAuth.auth | |
| frac_auth_auth_dfrac_op | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.auth_dfrac_op | |
| frac_auth_auth_dfrac_op_valid | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.auth_dfrac_op_valid | |
| frac_auth_auth_dfrac_op_validN | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.auth_dfrac_op_validN | |
| frac_auth_auth_dfrac_valid | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.auth_dfrac_valid | |
| frac_auth_auth_dfrac_validN | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.auth_dfrac_validN | |
| frac_auth_auth_discrete | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.auth_discrete | |
| frac_auth_auth_ne | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.auth_ne | |
| frac_auth_auth_op_valid | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.auth_op_valid | |
| frac_auth_auth_op_validN | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.auth_op_validN | |
| frac_auth_auth_proper | Derivable from auth_ne with NonExpansive.eqv | |
| frac_auth_auth_valid | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.auth_valid | |
| frac_auth_auth_validN | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.auth_validN | |
| frac_auth_dfrac_valid | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.dfrac_valid | |
| frac_auth_dfrac_validN | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.dfrac_validN | |
| frac_auth_frag | FracAuth.frag | |
| frac_auth_frag_discrete | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.frag_discrete | |
| frac_auth_frag_ne | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.frag_ne | |
| frac_auth_frag_op | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.frag_op | |
| frac_auth_frag_op_valid | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.frag_op_valid | |
| frac_auth_frag_op_validN | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.frag_op_validN | |
| frac_auth_frag_proper | Derivable from frag_ne with NonExpansive.eqv | |
| frac_auth_frag_valid | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.frag_valid | |
| frac_auth_frag_validN | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.frag_validN | |
| frac_auth_included | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.included | |
| frac_auth_includedN | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.includedN | |
| frac_auth_includedN_total | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.includedN_total | |
| frac_auth_included_total | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.included_total | |
| frac_auth_is_op | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.isOp_frac_auth | |
| frac_auth_is_op_core_id | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.isOp_frac_auth_core_id | |
| frac_auth_update | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.update | |
| frac_auth_updateP_auth_unpersist | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.updateP_auth_unpersist | |
| frac_auth_updateP_both_unpersist | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.updateP_both_unpersist | |
| frac_auth_update_1 | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.update_full | |
| frac_auth_update_auth_persist | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.update_auth_persist | |
| frac_auth_valid | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.valid | |
| frac_auth_validN | _private.Iris.Algebra.Lib.FracAuth.0.FracAuth.validN |
| Rocq Name | Status | Details |
|---|---|---|
| gmap_viewO | ||
| gmap_viewR | ||
| gmap_viewRF | ||
| gmap_viewRF_contractive | ||
| gmap_viewUR | ||
| gmap_viewURF | ||
| gmap_viewURF_contractive | ||
| gmap_view_alloc | ||
| gmap_view_alloc_big | ||
| gmap_view_auth | ||
| gmap_view_auth_dfrac_is_op | ||
| gmap_view_auth_dfrac_op | ||
| gmap_view_auth_dfrac_op_inv | ||
| gmap_view_auth_dfrac_op_invN | ||
| gmap_view_auth_dfrac_op_valid | ||
| gmap_view_auth_dfrac_op_validN | ||
| gmap_view_auth_dfrac_valid | ||
| gmap_view_auth_dfrac_validN | ||
| gmap_view_auth_ne | ||
| gmap_view_auth_op_valid | ||
| gmap_view_auth_op_validN | ||
| gmap_view_auth_persist | ||
| gmap_view_auth_proper | ||
| gmap_view_auth_unpersist | ||
| gmap_view_auth_valid | ||
| gmap_view_both_dfrac_validN | ||
| gmap_view_both_dfrac_validN_total | ||
| gmap_view_both_dfrac_valid_discrete | ||
| gmap_view_both_dfrac_valid_discrete_total | ||
| gmap_view_both_valid | ||
| gmap_view_both_validN | ||
| gmap_view_cmra_discrete | ||
| gmap_view_delete | ||
| gmap_view_delete_big | ||
| gmap_view_frag | ||
| gmap_view_fragUR | ||
| gmap_view_frag_add | ||
| gmap_view_frag_core_id | ||
| gmap_view_frag_dfrac | ||
| gmap_view_frag_mut_is_op | ||
| gmap_view_frag_ne | ||
| gmap_view_frag_op | ||
| gmap_view_frag_op_valid | ||
| gmap_view_frag_op_validN | ||
| gmap_view_frag_persist | ||
| gmap_view_frag_proper | ||
| gmap_view_frag_unpersist | ||
| gmap_view_frag_valid | ||
| gmap_view_frag_validN | ||
| gmap_view_rel | ||
| gmap_view_rel_discrete | ||
| gmap_view_rel_exists | ||
| gmap_view_rel_lookup | ||
| gmap_view_rel_raw | ||
| gmap_view_rel_raw_mono | ||
| gmap_view_rel_raw_unit | ||
| gmap_view_rel_raw_valid | ||
| gmap_view_rel_unit | ||
| gmap_view_replace | ||
| gmap_view_replace_big | ||
| gmap_view_update | ||
| gmap_view_update_local |
| Rocq Name | Status | Details |
|---|---|---|
| bij_both_dfrac_valid | ||
| bij_both_valid | ||
| bij_view_included | ||
| gset_bij | ||
| gset_bijO | ||
| gset_bijR | ||
| gset_bijUR | ||
| gset_bij_auth | ||
| gset_bij_auth_dfrac_op | ||
| gset_bij_auth_dfrac_op_valid | ||
| gset_bij_auth_dfrac_valid | ||
| gset_bij_auth_empty_dfrac_valid | ||
| gset_bij_auth_empty_valid | ||
| gset_bij_auth_extend | ||
| gset_bij_auth_op_valid | ||
| gset_bij_auth_valid | ||
| gset_bij_elem | ||
| gset_bij_elem_agree | ||
| gset_bij_elem_core_id | ||
| gset_bij_view_rel | ||
| gset_bij_view_rel_discrete | ||
| gset_bij_view_rel_iff | ||
| gset_bij_view_rel_raw | ||
| gset_bij_view_rel_raw_mono | ||
| gset_bij_view_rel_raw_unit | ||
| gset_bij_view_rel_raw_valid | ||
| gset_bijective | ||
| gset_bijective_empty | ||
| gset_bijective_eq_iff | ||
| gset_bijective_extend | ||
| gset_bijective_pair | ||
| subseteq_gset_bijective |
| Rocq Name | Status | Details |
|---|---|---|
| mono_Z | ||
| mono_ZR | ||
| mono_ZUR | ||
| mono_Z_auth | ||
| mono_Z_auth_core_id | ||
| mono_Z_auth_dfrac_is_op | ||
| mono_Z_auth_dfrac_op | ||
| mono_Z_auth_dfrac_op_valid | ||
| mono_Z_auth_dfrac_valid | ||
| mono_Z_auth_lb_op | ||
| mono_Z_auth_op_valid | ||
| mono_Z_auth_persist | ||
| mono_Z_auth_unpersist | ||
| mono_Z_auth_valid | ||
| mono_Z_both_dfrac_valid | ||
| mono_Z_both_valid | ||
| mono_Z_included | ||
| mono_Z_lb | ||
| mono_Z_lb_core_id | ||
| mono_Z_lb_max_is_op | ||
| mono_Z_lb_mono | ||
| mono_Z_lb_op | ||
| mono_Z_lb_op_le_l | ||
| mono_Z_update |
| Rocq Name | Status | Details |
|---|---|---|
| mono_listR | ||
| mono_listRF | ||
| mono_listRF_contractive | ||
| mono_listUR | ||
| mono_listURF | ||
| mono_listURF_contractive | ||
| mono_list_auth | ||
| mono_list_auth_core_id | ||
| mono_list_auth_dfrac_is_op | ||
| mono_list_auth_dfrac_op | ||
| mono_list_auth_dfrac_op_valid | ||
| mono_list_auth_dfrac_op_validN | ||
| mono_list_auth_dfrac_op_valid_L | ||
| mono_list_auth_dfrac_valid | ||
| mono_list_auth_dfrac_validN | ||
| mono_list_auth_lb_op | ||
| mono_list_auth_ne | ||
| mono_list_auth_op_valid | ||
| mono_list_auth_op_validN | ||
| mono_list_auth_persist | ||
| mono_list_auth_proper | ||
| mono_list_auth_unpersist | ||
| mono_list_auth_valid | ||
| mono_list_auth_validN | ||
| mono_list_both_dfrac_valid | ||
| mono_list_both_dfrac_validN | ||
| mono_list_both_dfrac_valid_L | ||
| mono_list_both_valid | ||
| mono_list_both_validN | ||
| mono_list_both_valid_L | ||
| mono_list_included | ||
| mono_list_lb | ||
| mono_list_lb_dist_inj | ||
| mono_list_lb_inj | ||
| mono_list_lb_mono | ||
| mono_list_lb_ne | ||
| mono_list_lb_op_l | ||
| mono_list_lb_op_r | ||
| mono_list_lb_op_valid | ||
| mono_list_lb_op_validN | ||
| mono_list_lb_op_valid_1_L | ||
| mono_list_lb_op_valid_2_L | ||
| mono_list_lb_op_valid_L | ||
| mono_list_lb_proper | ||
| mono_list_update |
| Rocq Name | Status | Details |
|---|---|---|
| mono_nat | ||
| mono_natR | ||
| mono_natUR | ||
| mono_nat_auth | Iris.MonoNat.auth | |
| mono_nat_auth_core_id | Iris.MonoNat.instCoreIdAuthDiscard | |
| mono_nat_auth_dfrac_is_op | Iris.MonoNat.instIsOpAuthOfDFrac | |
| mono_nat_auth_dfrac_op | Iris.MonoNat.auth_dfrac_op | |
| mono_nat_auth_dfrac_op_valid | Iris.MonoNat.auth_dfrac_op_valid | |
| mono_nat_auth_dfrac_valid | Iris.MonoNat.auth_dfrac_valid | |
| mono_nat_auth_lb_op | Iris.MonoNat.auth_lb_op | |
| mono_nat_auth_op_valid | Iris.MonoNat.auth_op_valid | |
| mono_nat_auth_persist | Iris.MonoNat.auth_persist | |
| mono_nat_auth_unpersist | Iris.MonoNat.auth_unpersist | |
| mono_nat_auth_valid | Iris.MonoNat.auth_valid | |
| mono_nat_both_dfrac_valid | Iris.MonoNat.both_dfrac_valid | |
| mono_nat_both_valid | Iris.MonoNat.both_valid | |
| mono_nat_included | Iris.MonoNat.included | |
| mono_nat_lb | Iris.MonoNat.lb | |
| mono_nat_lb_core_id | Iris.MonoNat.instCoreIdLb | |
| mono_nat_lb_max_is_op | Iris.MonoNat.instIsOpLbOfMaxNat | |
| mono_nat_lb_mono | Iris.MonoNat.lb_mono | |
| mono_nat_lb_op | Iris.MonoNat.lb_op | |
| mono_nat_lb_op_le_l | Iris.MonoNat.lb_op_le_l | |
| mono_nat_update | Iris.MonoNat.update |
| Rocq Name | Status | Details |
|---|---|---|
| ufrac_authR | ||
| ufrac_authRF | ||
| ufrac_authRF_contractive | ||
| ufrac_authUR | ||
| ufrac_authURF | ||
| ufrac_authURF_contractive | ||
| ufrac_auth_agree | ||
| ufrac_auth_agreeN | ||
| ufrac_auth_agree_L | ||
| ufrac_auth_auth | ||
| ufrac_auth_auth_discrete | ||
| ufrac_auth_auth_ne | ||
| ufrac_auth_auth_proper | ||
| ufrac_auth_auth_valid | ||
| ufrac_auth_auth_validN | ||
| ufrac_auth_frag | ||
| ufrac_auth_frag_discrete | ||
| ufrac_auth_frag_ne | ||
| ufrac_auth_frag_op | ||
| ufrac_auth_frag_op_valid | ||
| ufrac_auth_frag_op_validN | ||
| ufrac_auth_frag_proper | ||
| ufrac_auth_frag_valid | ||
| ufrac_auth_frag_validN | ||
| ufrac_auth_included | ||
| ufrac_auth_includedN | ||
| ufrac_auth_includedN_total | ||
| ufrac_auth_included_total | ||
| ufrac_auth_is_op | ||
| ufrac_auth_is_op_core_id | ||
| ufrac_auth_update | ||
| ufrac_auth_update_surplus | ||
| ufrac_auth_update_surplus_cancel | ||
| ufrac_auth_valid | ||
| ufrac_auth_validN |
| Rocq Name | Status | Details |
|---|---|---|
| app_dist_eq | ||
| app_ne | ||
| big_opL_ne_2 | ||
| cons_discrete | ||
| cons_dist_eq | ||
| cons_dist_inj | ||
| cons_ne | ||
| dist_Permutation | ||
| drop_ne | ||
| head_ne | ||
| imap_ne | ||
| last_ne | ||
| length_ne | ||
| listO | ||
| listOF | ||
| listOF_contractive | ||
| listO_map | ||
| listO_map_ne | ||
| list_alter_ne | ||
| list_bind_ne | ||
| list_compl_go | ||
| list_delete_ne | ||
| list_dist | ||
| list_dist_Forall2 | ||
| list_dist_lookup | ||
| list_filter_ne | ||
| list_fmap_dist_inj | ||
| list_fmap_ext_ne | ||
| list_fmap_ne | ||
| list_insert_ne | ||
| list_inserts_ne | ||
| list_join_ne | ||
| list_lbcompl_go | ||
| list_lookup_ne | ||
| list_lookup_total_ne | ||
| list_ofe_discrete | ||
| list_ofe_mixin | ||
| list_omap_ne | ||
| list_singleton_dist_eq | ||
| nil_discrete | ||
| nil_dist_eq | ||
| option_list_ne | ||
| replicate_ne | ||
| resize_ne | ||
| reverse_ne | ||
| tail_ne | ||
| take_ne | ||
| zip_with_ne |
| Rocq Name | Status | Details |
|---|---|---|
| local_update_preorder | ||
| alloc_option_local_update | Iris.LocalUpdate.alloc_option | |
| cancel_local_update | Iris.LocalUpdate.cancel | |
| cancel_local_update_unit | Iris.cancel_local_update_unit | |
| core_id_local_update | Iris.LocalUpdate.core_id | |
| delete_option_local_update | Iris.LocalUpdate.delete_option | |
| delete_option_local_update_cancelable | Iris.LocalUpdate.delete_option_cancelable | |
| discrete_fun_local_update | Iris.LocalUpdate.discrete_fun | |
| exclusive_local_update | Iris.LocalUpdate.exclusive | |
| local_update | Iris.LocalUpdate | |
| local_update_discrete | Iris.LocalUpdate.discrete | |
| local_update_proper | Iris.LocalUpdate.equiv | |
| local_update_total_valid | Iris.LocalUpdate.total_valid | |
| local_update_total_valid0 | Iris.LocalUpdate.total_valid0 | |
| local_update_unital | Iris.local_update_unital | |
| local_update_unital_discrete | Iris.local_update_unital_discrete | |
| local_update_valid | Iris.LocalUpdate.valid | |
| local_update_valid0 | Iris.LocalUpdate.valid0 | |
| op_local_update | Iris.LocalUpdate.op | |
| op_local_update_discrete | Iris.LocalUpdate.op_discrete | |
| op_local_update_frame | Iris.LocalUpdate.op_frame | |
| option_local_update | Iris.LocalUpdate.option | |
| option_local_update_None | Iris.LocalUpdate.option_none | |
| prod_local_update | Iris.LocalUpdate.prod | |
| prod_local_update' | Iris.LocalUpdate.prod' | |
| prod_local_update_1 | Iris.LocalUpdate.prod_1 | |
| prod_local_update_2 | Iris.LocalUpdate.prod_2 | |
| replace_local_update | Iris.LocalUpdate.replace | |
| unit_local_update | Iris.LocalUpdate.unit |
| Rocq Name | Status | Details |
|---|---|---|
| max_prefix_list | ||
| max_prefix_listR | ||
| max_prefix_listRF | ||
| max_prefix_listRF_contractive | ||
| max_prefix_listUR | ||
| max_prefix_listURF | ||
| max_prefix_listURF_contractive | ||
| max_prefix_list_included_includedN | ||
| max_prefix_list_local_update | ||
| mono_list_lb_core_id | ||
| to_max_prefix_list | ||
| to_max_prefix_list_app | ||
| to_max_prefix_list_dist_inj | ||
| to_max_prefix_list_included | ||
| to_max_prefix_list_includedN | ||
| to_max_prefix_list_includedN_aux | ||
| to_max_prefix_list_included_L | ||
| to_max_prefix_list_inj | ||
| to_max_prefix_list_ne | ||
| to_max_prefix_list_op_l | ||
| to_max_prefix_list_op_r | ||
| to_max_prefix_list_op_valid | ||
| to_max_prefix_list_op_validN | ||
| to_max_prefix_list_op_validN_aux | ||
| to_max_prefix_list_op_valid_L | ||
| to_max_prefix_list_proper | ||
| to_max_prefix_list_valid | ||
| to_max_prefix_list_validN |
| Rocq Name | Status | Details |
|---|---|---|
| Monoid | Iris.Algebra.MonoidOps | |
| MonoidHomomorphism | Iris.Algebra.MonoidHomomorphism | |
| MonoidOps | Not needed | |
| WeakMonoidHomomorphism | Iris.Algebra.WeakMonoidHomomorphism | |
| monoid_ops | Not needed | |
| monoid_proper | Iris.Algebra.MonoidOps.op_proper | |
| monoid_right_id | Iris.Algebra.MonoidOps.op_right_id | |
| weak_monoid_homomorphism_proper | Iris.Algebra.weak_monoid_homomorphism_equiv |
| Rocq Name | Status | Details |
|---|---|---|
| auth_ucmra_mixin | ||
| mra | ||
| mraO | ||
| mraR | ||
| mraUR | ||
| mra_below | ||
| mra_below_to_mra | ||
| mra_cmra_discrete | ||
| mra_cmra_mixin | ||
| mra_cmra_total | ||
| mra_core_id | ||
| mra_equiv | ||
| mra_equiv_equiv | ||
| mra_idemp | ||
| mra_included | ||
| mra_local_update_get_frag | ||
| mra_local_update_grow | ||
| mra_op | ||
| mra_pcore | ||
| mra_unit | ||
| mra_valid | ||
| mra_validN | ||
| to_mra | ||
| to_mra_R_op | ||
| to_mra_equiv_inj | ||
| to_mra_included | ||
| to_mra_inj | ||
| to_mra_proper | ||
| to_mra_rel_inj | ||
| to_mra_rel_proper |
| Rocq Name | Status | Details |
|---|---|---|
| Z_is_op | ||
| Z_local_update | ||
| max_Z_cmra_total | ||
| max_Z_included | ||
| max_Z_is_op | ||
| max_Z_local_update | ||
| max_nat_included | ||
| max_nat_is_op | ||
| max_nat_local_update | ||
| min_nat_included | ||
| min_nat_is_op | ||
| min_nat_local_update | ||
| nat_included | ||
| nat_is_op | ||
| nat_local_update | ||
| pos_included | ||
| pos_is_op | ||
| ZR | Use Int with scoped CMRA instance | |
| ZUR | Use Int with scoped UCMRA instance | |
| Z_cancelable | Use scoped Cancelable instance | |
| Z_cmra_discrete | Use scoped Discrete instance | |
| Z_op | CommMonoidLike.op_eq | |
| Z_op_instance | Use CMRA instance | |
| Z_pcore_instance | Use CMRA instance | |
| Z_ra_mixin | Not needed | |
| Z_ucmra_mixin | Not needed | |
| Z_unit_instance | Use UCMRA instance | |
| Z_validN_instance | Use CMRA instance | |
| Z_valid_instance | Use CMRA instance | |
| max_Z | Uses Int with IdempotentOp max | |
| max_ZO | Use LeibnizO Int | |
| max_ZR | Use Int with scoped CMRA instance | |
| max_Z_cmra_discrete | Use scoped Discrete instance | |
| max_Z_core_id | Use scoped CoreId instance | |
| max_Z_op | OrdCommMonoidLike.op_eq | |
| max_Z_op_instance | Use CMRA instance | |
| max_Z_pcore_instance | Use CMRA instance | |
| max_Z_ra_mixin | Not needed | |
| max_Z_unit_instance | Use UCMRA instance | |
| max_Z_validN_instance | Use CMRA instance | |
| max_Z_valid_instance | Use CMRA instance | |
| max_nat | Use Nat with IdempotentOp max | |
| max_natO | Use LeibnizO Nat | |
| max_natR | Use Nat with scoped CMRA instance | |
| max_natUR | Use Nat with scoped UCMRA instance | |
| max_nat_cmra_discrete | Use scoped Discrete instance | |
| max_nat_core_id | Use scoped CoreId instance | |
| max_nat_op | OrdCommMonoidLike.op_eq | |
| max_nat_op_instance | Use CMRA instance | |
| max_nat_pcore_instance | Use CMRA instance | |
| max_nat_ra_mixin | Not needed | |
| max_nat_ucmra_mixin | Not needed | |
| max_nat_unit_instance | Use UCMRA instance | |
| max_nat_validN_instance | Use CMRA instance | |
| max_nat_valid_instance | Use CMRA instance | |
| min_nat | Uses Nat with IdempotentOp min | |
| min_natO | Use LeibnizO Nat | |
| min_natR | Use Nat with scoped CMRA instance | |
| min_nat_cmra_discrete | Use scoped Discrete instance | |
| min_nat_core_id | Use scoped CoreId instance | |
| min_nat_op_instance | Use CMRA instance | |
| min_nat_op_min | OrdCommMonoidLike.op_eq | |
| min_nat_pcore_instance | Use CMRA instance | |
| min_nat_ra_mixin | Not needed | |
| min_nat_validN_instance | Use CMRA instance | |
| min_nat_valid_instance | Use CMRA instance | |
| natR | Use Nat with scoped CMRA instance | |
| natUR | Use Nat with scoped UCMRA instance | |
| nat_cancelable | Use scoped Cancelable instance | |
| nat_cmra_discrete | Use scoped Discrete instance | |
| nat_op | CommMonoidLike.op_eq | |
| nat_op_instance | Use CMRA instance | |
| nat_pcore_instance | Use CMRA instance | |
| nat_ra_mixin | Not needed | |
| nat_ucmra_mixin | Not needed | |
| nat_unit_instance | Use UCMRA instance | |
| nat_validN_instance | Use CMRA instance | |
| nat_valid_instance | Use CMRA instance | |
| pos_cancelable | Use scoped Cancelable instance | |
| pos_cmra_discrete | Use Discrete instance | |
| pos_id_free | Use scoped IdentityFree instance | |
| pos_op_add | Not needed | |
| pos_op_instance | Use CMRA instance | |
| pos_pcore_instance | Use CMRA instance | |
| pos_ra_mixin | Not needed | |
| pos_validN_instance | Use CMRA instance | |
| pos_valid_instance | Use CMRA instance | |
| positiveR | Use PNat with scoped CMRA instance |
| Rocq Name | Status | Details |
|---|---|---|
| Empty_setO | ||
| Empty_set_cofe | ||
| Empty_set_dist | ||
| Empty_set_ofe_discrete | ||
| Empty_set_ofe_mixin | ||
| Next_inj | ||
| Next_uninj | ||
| Prop_equiv | ||
| Prop_equivalence | ||
| Some_dist_inj | ||
| bchain | ||
| bchain_const | ||
| bchain_le | ||
| bchain_map | ||
| bchain_map_snd | ||
| bcompl | ||
| bcompl_ne | ||
| bfchain | ||
| bfchain_chain_unique | ||
| cconst | ||
| compl_bchain_map | ||
| contractive_alt | ||
| contractive_dist_later_dist | ||
| conv_bcompl | ||
| curry3_ne | ||
| curry4_ne | ||
| curry_ne | ||
| discrete_dist | ||
| discrete_funOF_contractive | ||
| discrete_fun_bchain | ||
| discrete_fun_lookup_discrete | ||
| discrete_fun_map_compose | ||
| discrete_fun_map_id | ||
| dist_Some_inv_l | ||
| dist_Some_inv_l' | ||
| dist_Some_inv_r | ||
| dist_pointwise_lt | ||
| equiv_dist | ||
| existT_proper_2 | ||
| exist_ne | ||
| fixpointK | ||
| fixpointK_ind | ||
| fixpointK_ne | ||
| fixpointK_proper | ||
| fixpointK_unfold | ||
| fixpointK_unique | ||
| fixpoint_A_proper | ||
| fixpoint_B_proper | ||
| fixpoint_bchain | ||
| fixpoint_bchain_go | ||
| fixpoint_chain | ||
| fixpoint_proper | ||
| fmap_Some_dist | ||
| inl_bchain | ||
| inl_ne_inj | ||
| inr_bchain | ||
| inr_ne_inj | ||
| is_Some_ne | ||
| iso_cofe | ||
| iso_cofe_subtype | ||
| iso_cofe_subtype' | ||
| iso_ofe_cong | ||
| iso_ofe_cong_contractive | ||
| iso_ofe_cong_ne | ||
| iso_ofe_mixin | ||
| laterO_map_contractive | ||
| later_car_anti_contractive | ||
| later_limit_bchain | ||
| later_map_Next | ||
| later_map_compose | ||
| later_map_ext | ||
| later_map_id | ||
| lbcompl_bchain_le | ||
| limit_preserving_bcompl | ||
| limit_preserving_impl' | ||
| limit_preserving_sidx_finite | ||
| ne_dist_later | ||
| oFunctor_oFunctor_compose | ||
| oFunctor_oFunctor_compose_contractive_1 | ||
| oFunctor_oFunctor_compose_contractive_2 | ||
| ofe_iso_cofe | ||
| ofe_iso_dist | ||
| ofe_iso_equiv | ||
| ofe_iso_ofe_mixin | ||
| ofe_mor_bchain | ||
| ofe_mor_lbcompl | ||
| option_bchain | ||
| option_fmap_dist_inj | ||
| option_lbcompl | ||
| pair_dist_inj | ||
| sigT_bchain_const_proj1 | ||
| sigT_dist_eq | ||
| sigT_dist_proj1 | ||
| sigT_equiv_eq | ||
| sigT_equiv_proj1 | ||
| sigT_lbcompl | ||
| sig_cofe | ||
| sig_ofe_discrete | ||
| sum_lbcompl | ||
| uncurry3_ne | ||
| uncurry4_ne | ||
| uncurry_ne | ||
| Cofe | Iris.IsCOFE | |
| Discrete | Iris.OFE.DiscreteE | |
| Discrete_proper | Iris.OFE.discreteE_eqv | |
| Dist | Use OFE.Dist | |
| LimitPreserving | Iris.LimitPreserving | |
| NO | Canonical Leibniz OFE on `N`; not applicable in Lean. | |
| Next_contractive | Iris.NextContractive | |
| None_discrete | Iris.OFE.Option.none_is_discrete | |
| OfeDiscrete | Iris.OFE.Discrete | |
| OfeMixin | Use the OFE type class | |
| PropO | Canonical discrete OFE on `Prop`; Lean uses `LeibnizO Prop`. | |
| Some_discrete | Iris.OFE.Option.some_is_discrete | |
| Some_ne | Iris.OFE.OFE.Option.some.ne | |
| ZO | Canonical Leibniz OFE on `Z`; not applicable in Lean. | |
| boolO | Canonical Leibniz OFE on `bool`; Lean uses `LeibnizO Bool`. | |
| ccompose | Iris.OFE.Hom.comp | |
| ccompose_ne | Implicit in type of ccompose | |
| ccompose_proper | Derived from nonexpansivity | |
| chain | Iris.Chain | |
| chain_const | Iris.Chain.const | |
| chain_map | Iris.Chain.map | |
| chain_map_snd | Iris.COFE.Sigma.chain_map_snd | |
| cid | Iris.OFE.Hom.id | |
| compl_chain_const | Iris.COFE.compl_const | |
| compl_chain_map | Iris.COFE.compl_map | |
| constOF | Iris.oFunctorConstOF | |
| constOF_contractive | Iris.OFunctor.constOF_contractive | |
| const_contractive | Iris.OFE.instContractive | |
| contractive_0 | Iris.OFE.Contractive.zero | |
| contractive_ne | Iris.OFE.ne_of_contractive | |
| contractive_proper | Iris.OFE.Contractive.eqv | |
| conv_compl_le | Iris.COFE.conv_compl' | |
| discrete | Iris.OFE.Discrete.discrete | |
| discrete_cofe | Iris.COFE.ofDiscrete | |
| discrete_fun | Lean uses `(x : α) → β x` directly with `OFEFun`. | |
| discrete_funO | Use a function type | |
| discrete_funOF | Iris.oFunctor_discreteFunOF | |
| discrete_funO_map | Iris.OFE.mapCodHom | |
| discrete_funO_map_ne | Implicit in type of mapCodHom | |
| discrete_fun_chain | Local helper; folded into Lean's IsCOFE instance. | |
| discrete_fun_cofe | Iris.COFE.instForall | |
| discrete_fun_dist | Local Dist instance; folded into Lean's instance. | |
| discrete_fun_equiv | Local Equiv instance; folded into Lean's instance. | |
| discrete_fun_map | Underlying map of mapCodHom | |
| discrete_fun_map_ext | Use ext | |
| discrete_fun_map_ne | Implicit in type of mapCodHom | |
| discrete_fun_ofe_mixin | Iris.OFE.instForallOfOFEFun | |
| discrete_iff | Iris.OFE.Discrete.discrete_iff | |
| discrete_iff_0 | Iris.OFE.Discrete.discrete_iff_0 | |
| discrete_ofe_discrete | Not needed | |
| discrete_ofe_mixin | Iris.OFE.ofDiscrete | |
| dist_None | Iris.OFE.dist_none | |
| dist_Some | Iris.OFE.some_dist_some | |
| dist_Some_inv_r' | Iris.OFE.dist_some | |
| dist_dist_later | Iris.OFE.Dist.distLater | |
| dist_equivalence | Iris.OFE.dist_equivalence | |
| dist_later | Iris.OFE.DistLater | |
| dist_later_0 | Iris.OFE.distLater_zero | |
| dist_later_dist_lt | Iris.OFE.DistLater.dist_lt | |
| dist_later_equivalence | Iris.OFE.distLater_eqv | |
| dist_le' | Use Dist.le | |
| dist_lt | Iris.OFE.Dist.lt | |
| dist_ne | Rewrite using Equiv.trans | |
| dist_proper | Rewrite using Equiv.trans | |
| dist_proper_2 | Rewrite using Equiv.trans | |
| existT_ne | Iris.OFE.Sigma.mk_dist | |
| existT_ne_2 | Iris.OFE.Sigma.mk_ne | |
| existT_proper | Iris.OFE.Sigma.mk_equiv | |
| fixpoint | Iris.fixpoint | |
| fixpoint_A | Iris.fixpointA | |
| fixpoint_AA | Iris.fixpointAA | |
| fixpoint_AA_contractive | Iris.fixpointAA_contractive | |
| fixpoint_AB | Iris.fixpointAB | |
| fixpoint_AB_contractive | Iris.fixpointAB_contractive | |
| fixpoint_A_ne | Iris.fixpointA_ne | |
| fixpoint_A_unfold | Iris.fixpointA_unfold | |
| fixpoint_A_unique | Iris.fixpointA_unique | |
| fixpoint_B | Iris.fixpointB | |
| fixpoint_B_ne | Iris.fixpointB_ne | |
| fixpoint_B_unfold | Iris.fixpointB_unfold | |
| fixpoint_B_unique | Iris.fixpointB_unique | |
| fixpoint_aux | Use fixpoint | |
| fixpoint_def | Use fixpoint | |
| fixpoint_ind | Iris.OFE.ContractiveHom.fixpoint_ind | |
| fixpoint_ne | Iris.OFE.ContractiveHom.fixpoint_ne | |
| fixpoint_unfold | Iris.fixpoint_unfold | |
| fixpoint_unique | Iris.fixpoint_unique | |
| fixpoint_unseal | fixpoint is unsealed by default | |
| from_option_ne | Iris.Option.elim_ne | |
| fst_ne | Iris.OFE.instNonExpansiveProdFst | |
| idOF | Iris.instOFunctorIdOF | |
| inl_chain | Local helper for `sum_compl`; folded into Lean's IsCOFE instance. | |
| inl_discrete | Iris.OFE.discreteE_inl | |
| inl_ne | Iris.OFE.instNonExpansiveInl | |
| inr_chain | Local helper for `sum_compl`; folded into Lean's IsCOFE instance. | |
| inr_discrete | Iris.OFE.discreteE_inr | |
| inr_ne | Iris.OFE.instNonExpansiveInr | |
| iso_ofe_refl | Iris.OFE.Iso.id | |
| iso_ofe_sym | Iris.OFE.Iso.symm | |
| iso_ofe_sym_ne | Implicit in the type of Iso.symm.hom | |
| iso_ofe_trans | Iris.OFE.Iso.comp | |
| iso_ofe_trans_ne | Implicit in the type of Iso.symm.inv | |
| later | Iris.Later | |
| laterO | Use the later type | |
| laterOF | Iris.instOFunctorLater | |
| laterOF_contractive | Iris.instOFunctorContractiveLater | |
| laterO_map | Iris.laterMap | |
| later_chain | Iris.laterChain | |
| later_cofe | Iris.isCOFE_later | |
| later_dist | Local Dist instance; folded into Lean's OFE (Later A) instance. | |
| later_equiv | Local Equiv instance; folded into Lean's OFE (Later A) instance. | |
| later_map | Underlying map of laterMap | |
| later_map_ne | Implicit in type of laterMap | |
| later_map_ne' | Implicit in type of laterMap | |
| later_map_proper | Derived from nonexpansivity | |
| later_ofe_mixin | Iris.isOFE_later | |
| leibnizO_leibniz | Iris.instLeibnizLeibnizO_1 | |
| limit_preserving_and | Iris.LimitPreserving.and | |
| limit_preserving_const | Iris.LimitPreserving.const | |
| limit_preserving_discrete | Iris.LimitPreserving.discrete | |
| limit_preserving_equiv | Iris.LimitPreserving.equiv | |
| limit_preserving_ext | Iris.LimitPreserving.ext | |
| limit_preserving_forall | Iris.LimitPreserving.forall | |
| limit_preserving_impl | Iris.LimitPreserving.impl | |
| natO | Canonical Leibniz OFE on `nat`; Lean uses `LeibnizO Nat`. | |
| ne_proper | Iris.OFE.NonExpansive.eqv | |
| ne_proper_2 | Iris.OFE.NonExpansive₂.eqv | |
| oFunctor | Iris.COFE.OFunctor | |
| oFunctorContractive | Iris.COFE.OFunctorContractive | |
| oFunctor_apply | Definition for application of an `oFunctor`; subsumed by `OFunctorPre` in Lean. | |
| ofe | Iris.OFE | |
| ofe_discrete_subrelation | Not needed | |
| ofe_equivalence | Iris.OFE.equiv_eqv | |
| ofe_iso | Iris.OFE.Iso | |
| ofe_isoO | Use Iso | |
| ofe_iso_1_ne | Implicit from the type of `Iso.Hom` | |
| ofe_iso_2_ne | Implicit from the type of `Iso.Inv` | |
| ofe_leibniz_subrelation | Generalized-rewriting subrelation; not needed in Lean. | |
| ofe_mixin_of' | Not needed | |
| ofe_mor | Iris.OFE.Hom | |
| ofe_morO | Use Hom type | |
| ofe_morOF | Iris.instOFunctorHomOF | |
| ofe_morOF_contractive | Iris.instOFunctorContractiveHomOF | |
| ofe_morO_map | Iris.Hom.map | |
| ofe_morO_map_ne | Iris.instNonExpansive₂HomMap | |
| ofe_mor_car_ne | Iris.OFE.ofe_mor_car_ne | |
| ofe_mor_car_proper | Iris.OFE.ofe_mor_car_proper | |
| ofe_mor_chain | Inlined in IsCOFE instance | |
| ofe_mor_cofe | Iris.COFE.instIsCOFEHom | |
| ofe_mor_compl | Inlined in IsCOFE instance | |
| ofe_mor_dist | Inlined in OFE (α -n> β) instance | |
| ofe_mor_equiv | Inlined in OFE (α -n> β) instance | |
| ofe_mor_ext | Use ext | |
| ofe_mor_inhabited | Iris.OFE.instInhabitedHom | |
| ofe_mor_map | Function-space map; subsumed by `Hom.map` in Lean. | |
| ofe_mor_map_ne | Function-space map proof; subsumed by `Hom.map` in Lean. | |
| ofe_mor_ofe_mixin | Iris.OFE.instHom | |
| ofe_mor_proper | Derived from nonexpansivity | |
| optionO | Use Option | |
| optionOF | Iris.oFunctorOption | |
| optionOF_contractive | Iris.instOFunctorContractiveOptionOF | |
| optionO_map | Iris.optionMap | |
| optionO_map_ne | Iris.optionMap_ne | |
| option_chain | Iris.optionChain | |
| option_cofe | Iris.isCOFE_option | |
| option_compl | Local Compl definition; folded into Lean's IsCOFE instance. | |
| option_dist | Local Dist instance; folded into Lean's OFE (Option α) instance. | |
| option_dist_Forall2 | Local Dist unfolding lemma; trivial in Lean. | |
| option_fmap_ne | Iris.Option.map_ne | |
| option_mbind_ne | Iris.Option.bind_ne | |
| option_mjoin_ne | Iris.Option.join_ne | |
| option_ofe_discrete | Iris.OFE.instDiscreteOption | |
| option_ofe_mixin | Iris.OFE.instOption | |
| pair_dist | Iris.OFE.dist_prod_ext | |
| pair_ne | Iris.OFE.Prod.mk_ne | |
| positiveO | Canonical Leibniz OFE on `positive`; not applicable in Lean. | |
| prodO | Use product type | |
| prodOF | Iris.instOFunctorProdOF | |
| prodOF_contractive | Iris.instOFunctorContractiveProdOF | |
| prodO_map | Iris.Prod.mapO | |
| prodO_map_ne | Iris.Prod.mapO_ne | |
| prod_cofe | Iris.COFE.instIsCOFEProd | |
| prod_discrete | Iris.OFE.prod.is_discrete | |
| prod_dist | Implicit in Prod OFE | |
| prod_map_ne | Iris.instNonExpansiveProdMap | |
| prod_ofe_discrete | Iris.OFE.instDiscreteProd | |
| prod_ofe_mixin | Iris.OFE.instProd | |
| proj1_sig_ne | Iris.OFE.instNonExpansiveSubtypeVal | |
| projT1_ne | Iris.OFE.Sigma.fst_ne | |
| projT1_proper | Derived from nonexpansivity. | |
| projT2_ne | Iris.OFE.Sigma.dist_snd | |
| projT2_proper | Iris.OFE.Sigma.equiv_snd | |
| sigO | Use subtype | |
| sigTO | Use sigma type | |
| sigTOF | Iris.instOFunctorSigmaOF | |
| sigTOF_contractive | Iris.instOFunctorContractiveSigmaOF | |
| sigT_chain_const_proj1 | Iris.COFE.Sigma.chain_const_proj1 | |
| sigT_cofe | Iris.COFE.instIsCOFESigma | |
| sigT_compl | Local Compl definition; folded into Lean's IsCOFE instance. | |
| sigT_discrete | Iris.OFE.instDiscreteESigma | |
| sigT_dist | Local Dist instance; folded into Lean's OFE (Sigma P) instance. | |
| sigT_equiv | Local Equiv instance; folded into Lean's OFE (Sigma P) instance. | |
| sigT_equiv_eq_alt | Iris.OFE.Sigma.equiv_eq_alt | |
| sigT_map | Iris.Sigma.mapO | |
| sigT_ofe_discrete | Iris.OFE.instDiscreteSigma | |
| sigT_ofe_mixin | Iris.OFE.instOFESigma | |
| sig_discrete | Iris.OFE.instDiscreteSubtype | |
| sig_dist | Local Dist instance; folded into Lean's OFE (Subtype P) instance. | |
| sig_dist_def | Trivial unfolding lemma; definitional in Lean. | |
| sig_equiv | Local Equiv instance; folded into Lean's OFE (Subtype P) instance. | |
| sig_equiv_def | Trivial unfolding lemma; definitional in Lean. | |
| sig_ofe_mixin | Iris.OFE.instSubtype | |
| snd_ne | Iris.OFE.instNonExpansiveProdSnd | |
| sumO | Use sum type | |
| sumOF | Iris.instOFunctorSumOF | |
| sumOF_contractive | Iris.instOFunctorContractiveSumOF | |
| sumO_map | Iris.Sum.mapO | |
| sumO_map_ne | Iris.Sum.mapO_ne | |
| sum_cofe | Iris.COFE.instIsCOFESum | |
| sum_compl | Local Compl definition; folded into Lean's IsCOFE instance. | |
| sum_dist | Inlined in OFE (α ⊕ β) instance | |
| sum_map_ne | Iris.instNonExpansiveSumMap | |
| sum_ofe_discrete | Iris.OFE.instDiscreteSum | |
| sum_ofe_mixin | Iris.OFE.instSum | |
| unitO | Use the unit type | |
| unit_cofe | Iris.COFE.instUnit | |
| unit_dist | Local Dist instance; folded into Lean's OFE Unit instance. | |
| unit_ofe_discrete | Iris.COFE.instDiscreteUnit | |
| unit_ofe_mixin | Iris.OFE.instUnit |
| Rocq Name | Status | Details |
|---|---|---|
| IsOp | Iris.IsOp | |
| IsOp' | Iris.IsOp | |
| IsOp'LR | Iris.IsOp | |
| is_op_Some | Iris.isOp_some | |
| is_op_lr_op | Iris.isOpSplit_op | |
| is_op_op | Iris.isOpMerge_op | |
| is_op_pair | Iris.isOp_pair | |
| is_op_pair_core_id_l | Iris.isOp_pair_core_id_l | |
| is_op_pair_core_id_r | Iris.isOpMerge_pair_core_id_r |
| Rocq Name | Status | Details |
|---|---|---|
| ReservationMap_ne | ||
| ReservationMap_proper | ||
| reservation_map_data_core_id | ||
| reservation_map_data_proj_ne | ||
| reservation_map_data_proj_proper | ||
| reservation_map_data_proj_validN | ||
| reservation_map_dist | ||
| reservation_map_empty_instance | ||
| reservation_map_equiv | ||
| reservation_map_included | ||
| reservation_map_op_instance | ||
| reservation_map_pcore_instance | ||
| reservation_map_token_proj_validN | ||
| reservation_map_validN_eq | ||
| reservation_map_validN_instance | ||
| reservation_map_valid_eq | ||
| reservation_map_valid_instance | ||
| ReservationMap_discrete | Iris.instDiscreteEReservationMapMk | |
| reservation_map | Iris.ReservationMap | |
| reservation_mapO | Iris.instOFEReservationMap | |
| reservation_mapR | Derivable using UCMRA | |
| reservation_mapUR | Iris.ReservationMap.instUCMRA | |
| reservation_map_alloc | Iris.ReservationMap.alloc | |
| reservation_map_cmra_discrete | Iris.ReservationMap.instDiscrete | |
| reservation_map_cmra_mixin | Not needed | |
| reservation_map_data | Iris.ReservationMap.singleton | |
| reservation_map_data_discrete | Iris.instDiscreteEReservationMapSingleton | |
| reservation_map_data_is_op | Iris.ReservationMap.instIsOpSingleton | |
| reservation_map_data_mono | Iris.ReservationMap.singleton_mono | |
| reservation_map_data_ne | Iris.instNonExpansiveReservationMapSingleton | |
| reservation_map_data_op | Iris.ReservationMap.singleton_op | |
| reservation_map_data_proper | Derivable using NonExpansive.eqv | |
| reservation_map_data_valid | Iris.ReservationMap.valid_singleton | |
| reservation_map_ofe_discrete | Iris.instDiscreteReservationMap | |
| reservation_map_ofe_mixin | Not needed | |
| reservation_map_token | Iris.ReservationMap.mkToken | |
| reservation_map_token_difference | Iris.ReservationMap.token_difference | |
| reservation_map_token_discrete | Iris.instDiscreteEReservationMapToken | |
| reservation_map_token_union | Iris.ReservationMap.token_union | |
| reservation_map_token_valid | Iris.ReservationMap.valid_token | |
| reservation_map_token_valid_op | Iris.ReservationMap.valid_token_op_iff_disj | |
| reservation_map_ucmra_mixin | Not needed | |
| reservation_map_update | Iris.ReservationMap.reservation_map_update | |
| reservation_map_updateP | Iris.ReservationMap.updateP |
| Rocq Name | Status | Details |
|---|---|---|
| SIdx.case | ||
| SIdx.eq_dec | ||
| SIdx.inhabited | ||
| SIdx.le_0_l | ||
| SIdx.le_0_r | ||
| SIdx.le_dec | ||
| SIdx.le_gt_cases | ||
| SIdx.le_lt_trans | ||
| SIdx.le_lteq | ||
| SIdx.le_neq | ||
| SIdx.le_ngt | ||
| SIdx.le_po | ||
| SIdx.le_succ_diag_r | ||
| SIdx.le_succ_l | ||
| SIdx.le_succ_l_2 | ||
| SIdx.le_total | ||
| SIdx.limit | ||
| SIdx.limit_0 | ||
| SIdx.limit_S | ||
| SIdx.limit_finite | ||
| SIdx.limit_lt_0 | ||
| SIdx.lt_dec | ||
| SIdx.lt_ge_cases | ||
| SIdx.lt_le_incl | ||
| SIdx.lt_le_trans | ||
| SIdx.lt_nge | ||
| SIdx.lt_strict | ||
| SIdx.lt_succ_diag_r | ||
| SIdx.lt_succ_diag_r' | ||
| SIdx.lt_succ_r | ||
| SIdx.lt_trans | ||
| SIdx.lt_trichotomy | ||
| SIdx.lt_wf | ||
| SIdx.neq_0_lt_0 | ||
| SIdx.neq_succ_0 | ||
| SIdx.nlt_0_r | ||
| SIdx.nlt_succ_r | ||
| SIdx.rec | ||
| SIdx.rec_lim | ||
| SIdx.rec_lim_ext | ||
| SIdx.rec_succ | ||
| SIdx.rec_unfold | ||
| SIdx.rec_zero | ||
| SIdx.succ_inj | ||
| SIdx.succ_le_mono | ||
| SIdx.succ_lt_mono | ||
| SIdx.succ_neq | ||
| SIdx.weak_case | ||
| SIdxFinite | ||
| SIdxMixin | ||
| sidx |
| Rocq Name | Status | Details |
|---|---|---|
| cmra_validN_S | ||
| cofe_finite | ||
| conv_compl_S | ||
| dist_later_fin | ||
| dist_later_fin_iff | ||
| natSI | ||
| nat_sidx_finite | ||
| nat_sidx_mixin | ||
| ofe_mixin_finite | ||
| cmra_includedN_S | Iris.CMRA.incN_of_incN_succ | |
| contractive_S | Iris.OFE.Contractive.succ | |
| dist_S | Subsumed by `Dist.lt`/`Dist.le`. | |
| dist_later_S | Iris.OFE.distLater_succ | |
| dist_le | Iris.OFE.Dist.le |
| Rocq Name | Status | Details |
|---|---|---|
| auth_proper | ||
| frag_proper | ||
| sts.car | ||
| sts.closed | ||
| sts.closed_op | ||
| sts.closed_proper | ||
| sts.closed_proper' | ||
| sts.closed_steps | ||
| sts.closed_up | ||
| sts.closed_up_empty | ||
| sts.closed_up_set | ||
| sts.closed_up_set_empty | ||
| sts.elem_of_up | ||
| sts.elem_of_up_set | ||
| sts.frame_step | ||
| sts.frame_step_mono | ||
| sts.frame_step_proper | ||
| sts.step | ||
| sts.step_closed | ||
| sts.steps_closed | ||
| sts.stsT | ||
| sts.subseteq_up_set | ||
| sts.up | ||
| sts.up_closed | ||
| sts.up_op | ||
| sts.up_preserving | ||
| sts.up_proper | ||
| sts.up_set | ||
| sts.up_set_preserving | ||
| sts.up_set_proper | ||
| sts.up_set_subseteq | ||
| sts.up_subseteq | ||
| sts.up_up_set | ||
| sts_auth | ||
| sts_auth_frag_op | ||
| sts_auth_frag_up_op | ||
| sts_auth_frag_valid_inv | ||
| sts_auth_proper | ||
| sts_auth_valid | ||
| sts_car_core_disjoint_l | ||
| sts_car_core_idemp | ||
| sts_car_core_instance | ||
| sts_car_core_l | ||
| sts_car_core_mono | ||
| sts_car_core_proper | ||
| sts_car_core_valid | ||
| sts_car_disjoint_instance | ||
| sts_car_disjoint_ll | ||
| sts_car_disjoint_lr | ||
| sts_car_disjoint_move_l | ||
| sts_car_disjoint_move_r | ||
| sts_car_disjoint_proper | ||
| sts_car_disjoint_proper' | ||
| sts_car_disjoint_rl | ||
| sts_car_disjoint_symmetric | ||
| sts_car_equiv | ||
| sts_car_equivalence | ||
| sts_car_op_assoc | ||
| sts_car_op_comm | ||
| sts_car_op_proper | ||
| sts_car_op_valid | ||
| sts_car_valid_instance | ||
| sts_car_valid_proper | ||
| sts_car_valid_proper' | ||
| sts_equiv | ||
| sts_equivalence | ||
| sts_frag | ||
| sts_frag_core_id | ||
| sts_frag_op | ||
| sts_frag_proper | ||
| sts_frag_up | ||
| sts_frag_up_proper | ||
| sts_frag_up_valid | ||
| sts_frag_valid | ||
| sts_notok.frame_prim_step | ||
| sts_notok.mk_closed | ||
| sts_notok.prim_frame_step | ||
| sts_notok.stsT | ||
| sts_notok.stsT_tok | ||
| sts_notok.stsT_token | ||
| sts_notok.sts_notok | ||
| sts_notok.sts_step | ||
| sts_notok.sts_steps | ||
| sts_notok_update_auth | ||
| sts_op_instance | ||
| sts_res | ||
| sts_resO | ||
| sts_resR | ||
| sts_res_cmra_total | ||
| sts_res_disrete_cmra | ||
| sts_res_op_instance | ||
| sts_res_pcore_instance | ||
| sts_res_ra_mixin | ||
| sts_res_valid_instance | ||
| sts_up_set_intersection | ||
| sts_update_auth | ||
| sts_update_frag | ||
| sts_update_frag_up | ||
| to_sts_res | ||
| to_sts_res_op | ||
| to_sts_res_proper |
| Rocq Name | Status | Details |
|---|---|---|
| is_op_ufrac | ||
| ufrac | ||
| ufracO | ||
| ufracR | ||
| ufrac_cancelable | ||
| ufrac_cmra_discrete | ||
| ufrac_id_free | ||
| ufrac_included | ||
| ufrac_included_weak | ||
| ufrac_op | ||
| ufrac_op_instance | ||
| ufrac_pcore_instance | ||
| ufrac_ra_mixin | ||
| ufrac_valid_instance |
| Rocq Name | Status | Details |
|---|---|---|
| cmra_transport_updateP | ||
| cmra_transport_updateP' | ||
| cmra_update_flip_proper_update | ||
| cmra_update_op_flip_proper | ||
| cmra_update_op_proper | ||
| cmra_update_preorder | ||
| cmra_update_proper_update | ||
| cmra_discrete_total_update | Iris.Update.discrete_total | |
| cmra_discrete_total_updateP | Iris.UpdateP.discrete_total | |
| cmra_discrete_update | Iris.Update.discrete | |
| cmra_discrete_updateP | Iris.UpdateP.discrete | |
| cmra_total_update | Iris.Update.total | |
| cmra_total_updateP | Iris.UpdateP.total | |
| cmra_update | Iris.Update | |
| cmra_updateP | Iris.UpdateP | |
| cmra_updateP_compose | Iris.UpdateP.trans | |
| cmra_updateP_compose_l | Iris.Update.transP | |
| cmra_updateP_id | Iris.UpdateP.id | |
| cmra_updateP_op | Iris.UpdateP.op | |
| cmra_updateP_op' | Iris.UpdateP.op' | |
| cmra_updateP_proper | Follows from UpdateP.equiv_left | |
| cmra_updateP_weaken | Iris.UpdateP.weaken | |
| cmra_update_exclusive | Iris.Update.exclusive | |
| cmra_update_included | Iris.Update.included | |
| cmra_update_lift_updateP | Iris.Update.lift_updateP | |
| cmra_update_op | Iris.Update.op | |
| cmra_update_op_l | Iris.Update.op_l | |
| cmra_update_op_r | Iris.Update.op_r | |
| cmra_update_proper | Follows from Update.equiv_left | |
| cmra_update_rewrite_relation | Not needed | |
| cmra_update_updateP | Iris.Update.of_updateP | |
| cmra_update_valid0 | Iris.Update.valid0 | |
| iso_cmra_updateP | Iris.UpdateP.iso | |
| iso_cmra_updateP' | Iris.UpdateP.iso' | |
| option_update | Iris.Update.option | |
| option_updateP | Iris.UpdateP.option | |
| option_updateP' | Iris.UpdateP.option' | |
| prod_update | Iris.Update.prod | |
| prod_updateP | Iris.UpdateP.prod | |
| prod_updateP' | Iris.UpdateP.prod' |
| Rocq Name | Status | Details |
|---|---|---|
| list_cofe | ||
| vcons_discrete | ||
| vcons_ne | ||
| vcons_proper | ||
| vecO | ||
| vecOF | ||
| vecOF_contractive | ||
| vecO_map | ||
| vecO_map_ne | ||
| vec_dist | ||
| vec_equiv | ||
| vec_map | ||
| vec_map_ext_ne | ||
| vec_map_ne | ||
| vec_ofe_discrete | ||
| vec_ofe_mixin | ||
| vec_to_list_ne | ||
| vec_to_list_proper | ||
| vlookup_ne | ||
| vlookup_proper | ||
| vnil_discrete |
| Rocq Name | Status | Details |
|---|---|---|
| big_opL_view_frag | ||
| big_opMS_view_frag | ||
| big_opM_view_frag | ||
| big_opS_view_frag | ||
| viewO_map_ne | ||
| view_frag_sep_homomorphism | ||
| ViewRelDiscrete | IsViewRelDiscrete | |
| View_discrete | View.discrete | |
| View_ne | View.mk.ne | |
| View_proper | Derived from View.mk.ne | |
| view | View | |
| viewO | Use the plain View type and typeclass inference | |
| viewO_map | View.mapO | |
| viewR | Use the plain View type | |
| viewUR | View.instUCMRA | |
| view_auth | View.Auth | |
| view_auth_core_id | View.instCoreIdAuthDiscard | |
| view_auth_dfrac_included | View.auth_inc_auth_op_frag_iff | |
| view_auth_dfrac_includedN | View.auth_incN_auth_op_frag_iff | |
| view_auth_dfrac_is_op | View.isOp_view_auth_dfrac | |
| view_auth_dfrac_op | View.auth_op_auth_eqv | |
| view_auth_dfrac_op_inv | View.eqv_of_valid_auth | |
| view_auth_dfrac_op_invN | View.dist_of_validN_auth | |
| view_auth_dfrac_op_inv_L | View.eq_of_valid_auth | |
| view_auth_dfrac_op_valid | View.auth_op_auth_valid_iff | |
| view_auth_dfrac_op_validN | View.auth_op_auth_validN_iff | |
| view_auth_dfrac_valid | View.auth_valid_iff | |
| view_auth_dfrac_validN | View.auth_validN_iff | |
| view_auth_discrete | View.auth_discrete | |
| view_auth_dist_inj | View.auth_dist_inj | |
| view_auth_included | View.auth_one_inc_auth_one_op_frag_iff | |
| view_auth_includedN | View.auth_one_incN_auth_one_op_frag_iff | |
| view_auth_inj | View.auth_eqv_inj | |
| view_auth_ne | View.auth_ne | |
| view_auth_op_valid | View.auth_one_op_auth_one_valid_iff | |
| view_auth_op_validN | View.auth_one_op_auth_one_validN_iff | |
| view_auth_proj_ne | View.auth.ne | |
| view_auth_proj_proper | Derived from View.auth.ne | |
| view_auth_proper | Derivable from auth_ne with NonExpansive.eqv | |
| view_auth_valid | View.auth_one_valid_iff | |
| view_auth_validN | View.auth_one_validN_iff | |
| view_both_core_discarded | View.auth_discard_op_frag_core | |
| view_both_core_frac | View.auth_own_op_frag_core | |
| view_both_core_id | View.instCoreIdOpAuthDiscardFrag | |
| view_both_dfrac_included | View.auth_op_frag_inc_auth_op_frag_iff | |
| view_both_dfrac_includedN | View.auth_op_frag_incN_auth_op_frag_iff | |
| view_both_dfrac_valid | View.auth_op_frag_valid_iff | |
| view_both_dfrac_validN | View.auth_op_frag_validN_iff | |
| view_both_included | View.auth_one_op_frag_inc_auth_one_op_frag_iff | |
| view_both_includedN | View.auth_one_op_frag_incN_auth_one_op_frag_iff | |
| view_both_valid | View.auth_one_op_frag_valid_iff | |
| view_both_validN | View.auth_one_op_frag_validN_iff | |
| view_cmra_discrete | View.instDiscreteOfDiscreteOfIsViewRelDiscrete | |
| view_cmra_mixin | View.instCMRA | |
| view_core_eq | Not needed | |
| view_dist | View.dist | |
| view_empty_instance | Inlined in the UCMRA instance | |
| view_equiv | View.equiv | |
| view_frag | View.Frag | |
| view_frag_core | View.frag_core | |
| view_frag_core_id | View.instCoreIdFrag | |
| view_frag_discrete | View.frag_discrete | |
| view_frag_dist_inj | View.dist_of_frag_dist | |
| view_frag_included | View.frag_inc_auth_op_frag_iff | |
| view_frag_includedN | View.frag_incN_auth_op_frag_iff | |
| view_frag_inj | View.frag_eqv_inj | |
| view_frag_is_op | View.instIsOpFrag | |
| view_frag_mono | View.frag_inc_of_inc | |
| view_frag_ne | View.frag_ne | |
| view_frag_op | View.frag_op_eq | |
| view_frag_proj_ne | View.frag.ne | |
| view_frag_proj_proper | Derived from View.frag.ne | |
| view_frag_proper | Derivable from frag_ne with NonExpansive.eqv | |
| view_frag_valid | View.frag_valid_iff | |
| view_frag_validN | View.frag_validN_iff | |
| view_local_update | View.view_local_update | |
| view_map | View.map | |
| view_map_cmra_morphism | View.mapC | |
| view_map_compose | View.map_compose | |
| view_map_ext | View.map_ext | |
| view_map_id | View.map_id | |
| view_map_ne | View.instNonExpansiveMap | |
| view_ofe_discrete | View.instDiscrete | |
| view_ofe_mixin | View.instOFE | |
| view_op_eq | Not needed | |
| view_op_instance | In the CMRA instance | |
| view_pcore_eq | Not needed | |
| view_pcore_instance | In the CMRA instance | |
| view_rel | IsViewRel | |
| view_rel_ne | ViewRel.iff_of_dist | |
| view_rel_proper | ViewRel.iff_of_equiv | |
| view_ucmra_mixin | Not needed | |
| view_update | View.auth_one_op_frag_update | |
| view_updateP | View.auth_one_op_frag_updateP | |
| view_updateP_auth_dfrac | View.auth_updateP | |
| view_updateP_auth_unpersist | View.auth_acquire | |
| view_updateP_both_unpersist | View.auth_op_frag_acquire | |
| view_updateP_frag | View.frag_updateP | |
| view_update_alloc | View.auth_one_alloc | |
| view_update_auth | View.auth_one_update | |
| view_update_auth_persist | View.auth_discard | |
| view_update_dealloc | View.auth_one_op_frag_dealloc | |
| view_update_dfrac_alloc | View.auth_alloc | |
| view_update_frag | View.frag_update | |
| view_validN_eq | Not needed | |
| view_validN_instance | In the CMRA instance | |
| view_valid_eq | Not needed | |
| view_valid_instance | In the CMRA instance |
▶
base_logic/639/963 (66%)| Rocq Name | Status | Details |
|---|---|---|
| pure_ne | ||
| pure_elim' | Inlined in `uPredI` construction | |
| pure_intro | Inlined in `uPredI` construction | |
| uPred.bupd_ownM_updateP | UPred.bupd_ownM_updateP | |
| uPred.later_ownM | UPred.later_ownM | |
| uPred.ownM_forall | UPred.ownM_forall | |
| uPred.ownM_ne | UPred.ownM_ne | |
| uPred.ownM_op | UPred.ownM_op | |
| uPred.ownM_unit | UPred.ownM_unit | |
| uPred.ownM_valid | UPred.ownM_valid | |
| uPred.persistently_ownM_core | UPred.persistently_ownM_core | |
| uPred.uPred_and_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_bupd_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_emp_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_exist_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_forall_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_impl_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_later_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_or_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_persistently_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_pure_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_sep_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_si_emp_valid_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_si_pure_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPred.uPred_unseal | No `Ltac unseal` rewrite is needed; nothing is sealed. | |
| uPred.uPred_wand_unseal | Connectives are defined directly without `seal`/`unseal`. | |
| uPredI | UPred.instBIUPred | |
| uPred_affine | UPred.instBIAffineUPred | |
| uPred_bi_bupd | UPred.instBIUpdateUPred | |
| uPred_bi_bupd_sbi | UPred.instBIBUpdateSbiUPred | |
| uPred_bi_later_mixin | Inlined in `uPredI` construction | |
| uPred_bi_mixin | Inlined in `uPredI` construction | |
| uPred_bi_persistently_mixin | Inlined in `uPredI` construction | |
| uPred_bupd_mixin | Inlined in BIUpdate instance construction | |
| uPred_emp | UPred.emp | |
| uPred_later_contractive | UPred.instBILaterContractiveUPred | |
| uPred_persistently_forall | UPred.instBIPersistentlyForallUPred | |
| uPred_pure | UPred.pure | |
| uPred_pure_forall | BiPureForall is not needed | |
| uPred_sbi | UPred.instSbiUPred | |
| uPred_sbi_emp_valid_exist | UPred.instSbiEmpValidExistUPred | |
| uPred_sbi_mixin | Inlined in uPred_sbi construction | |
| uPred_sbi_prop_ext_mixin | Inlined in uPred_sbi construction |
| Rocq Name | Status | Details |
|---|---|---|
| bupd_alt_bupd | ||
| bupd_alt_bupd_iff | ||
| bupd_alt_flip_mono' | ||
| bupd_alt_mono' | ||
| bupd_alt_proper | ||
| ownM_updateP | ||
| bupd_alt | Iris.BUpdPlain.BUpdPlain | |
| bupd_alt_frame_r | Iris.BUpdPlain.BUpdPlain_frame_right | |
| bupd_alt_intro | Iris.BUpdPlain.BUpdPlain_intro | |
| bupd_alt_mono | Iris.BUpdPlain.BUpdPlain_mono | |
| bupd_alt_ne | Iris.BUpdPlain.BUpdPlain_ne | |
| bupd_alt_plainly | Iris.BUpdPlain.BUpdPlain_plainly | |
| bupd_alt_trans | Iris.BUpdPlain.BUpdPlain_idem | |
| bupd_bupd_alt | Iris.BUpdPlain.BUpd_BUpdPlain |
| Rocq Name | Status | Details |
|---|---|---|
| uPred.consistency | ||
| uPred.denote_modalities | ||
| uPred.denote_modality | ||
| uPred.modal_soundness | ||
| uPred.modality | ||
| uPred.ownM_proper | ||
| uPred.uPred_ownM_sep_homomorphism | ||
| uPred.bupd_ownM_update | UPred.bupd_ownM_update | |
| uPred.bupd_soundness | UPred.bupd_soundness | |
| uPred.intuitionistically_ownM | UPred.intuitionistically_ownM | |
| uPred.ownM_invalid | UPred.ownM_invalid | |
| uPred.ownM_mono | UPred.ownM_mono | |
| uPred.ownM_persistent | UPred.ownM_persistent | |
| uPred.ownM_timeless | UPred.ownM_timeless | |
| uPred.ownM_unit' | UPred.ownM_unit' |
| Rocq Name | Status | Details |
|---|---|---|
| box | ||
| boxG | ||
| box_alloc | ||
| box_contractive | ||
| box_empty | ||
| box_fill | ||
| box_inv_ne | ||
| box_ne | ||
| box_own_agree | ||
| box_own_auth | ||
| box_own_auth_agree | ||
| box_own_auth_update | ||
| box_own_prop | ||
| box_own_prop_contractive | ||
| box_own_prop_ne | ||
| box_proper | ||
| boxΣ | ||
| slice | ||
| slice_combine | ||
| slice_contractive | ||
| slice_delete_empty | ||
| slice_delete_full | ||
| slice_empty | ||
| slice_fill | ||
| slice_iff | ||
| slice_insert_empty | ||
| slice_insert_full | ||
| slice_inv | ||
| slice_name | ||
| slice_ne | ||
| slice_persistent | ||
| slice_proper | ||
| slice_split | ||
| subG_boxΣ |
| Rocq Name | Status | Details |
|---|---|---|
| cinv_inv | ||
| cinvΣ | ||
| into_acc_cinv | ||
| into_inv_cinv | ||
| subG_cinvΣ | ||
| cinv | Iris.CancelableInvariant.cinv | |
| cinvG | Iris.CInvG | |
| cinv_acc | Iris.CancelableInvariant.acc | |
| cinv_acc_1 | Iris.CancelableInvariant.acc_one | |
| cinv_acc_strong | Iris.CancelableInvariant.acc_strong | |
| cinv_alloc | Iris.CancelableInvariant.alloc | |
| cinv_alloc_cofinite | Iris.CancelableInvariant.alloc_cofinite | |
| cinv_alloc_open | Iris.CancelableInvariant.alloc_open | |
| cinv_alloc_strong | Iris.CancelableInvariant.alloc_strong | |
| cinv_alloc_strong_open | Iris.CancelableInvariant.alloc_strong_open | |
| cinv_cancel | Iris.CancelableInvariant.cancel | |
| cinv_contractive | Iris.CancelableInvariant.instContractiveCinv | |
| cinv_excl | Iris.CancelableInvariant.excl | |
| cinv_excl_excl | Iris.CancelableInvariant.excl_excl | |
| cinv_iff | Iris.CancelableInvariant.cinv_iff | |
| cinv_ne | Iris.CancelableInvariant.instNonExpansiveCinv | |
| cinv_own | Iris.CancelableInvariant.own | |
| cinv_own_1_l | Iris.CancelableInvariant.own_one_l | |
| cinv_own_as_fractional | Iris.CancelableInvariant.instAsFractionalOwn | |
| cinv_own_excl_alloc | Iris.CancelableInvariant.own_excl_alloc | |
| cinv_own_fractional | Iris.CancelableInvariant.instFractionalOwn | |
| cinv_own_timeless | Iris.CancelableInvariant.instTimelessOwn | |
| cinv_own_valid | Iris.CancelableInvariant.own_valid | |
| cinv_persistent | Iris.CancelableInvariant.instPersistentCinv | |
| cinv_proper | Subsumed by instNonExpansiveCinv |
| Rocq Name | Status | Details |
|---|---|---|
| tac_lc_add_laterN_split | ||
| elim_modal_bupd_fupd_finally | Iris.elimModal_bupd_fupd_finally | |
| elim_modal_fupd_fupd_finally | Iris.elimModal_fupd_fupd_finally | |
| from_forall_fupd_finally | Iris.fromForall_fupd_finally | |
| from_forall_fupd_pure | Iris.fromForall_fupd_pure | |
| from_modal_fupd_finally | Iris.fromModal_fupd_finally | |
| from_pure_fupd_finally | Iris.fromPure_fupd_finally | |
| fupd_finally | Iris.fupd_finally | |
| fupd_finally_add_lc | Iris.fupd_finally_add_lc | |
| fupd_finally_and | Iris.fupd_finally_and | |
| fupd_finally_aux | Not needed | |
| fupd_finally_def | Not needed | |
| fupd_finally_except_0 | Iris.fupd_finally_except0 | |
| fupd_finally_flip_mono' | Subsumed by `fupd_finally_mono` | |
| fupd_finally_forall | Iris.fupd_finally_forall | |
| fupd_finally_intro | Iris.fupd_finally_intro | |
| fupd_finally_keep | Iris.fupd_finally_keep | |
| fupd_finally_later | Iris.fupd_finally_later | |
| fupd_finally_mask_mono | Iris.fupd_finally_mask_mono | |
| fupd_finally_mono | Iris.fupd_finally_mono | |
| fupd_finally_mono' | Subsumed by `fupd_finally_mono` | |
| fupd_finally_ne | Iris.fupd_finally_ne | |
| fupd_finally_proper | Subsumed by the NonExpansive instance `fupd_finally_ne` | |
| fupd_finally_soundness | Iris.fupd_finally_soundness | |
| fupd_finally_unseal | Not needed | |
| fupd_finally_wand | Iris.fupd_finally_wand | |
| fupd_fupd_finally | Iris.fupd_fupd_finally | |
| fupd_keep | Iris.fupd_keep | |
| fupd_keep_pure | Iris.fupd_keep_pure | |
| fupd_pure_forall | Iris.fupd_pure_forall | |
| fupd_soundness | Iris.fupd_soundness | |
| fupd_soundness_no_lc_unfold | Iris.fupd_soundness_no_lc_unfold | |
| fupd_unfold_no_lc | Iris.fupd_unfold_no_lc | |
| invGS_gen | Iris.InvGS_gen | |
| invGpreS | Iris.InvGpreS | |
| invΣ | Superseded by the `InvGpreS` typeclass on `BundledGFunctors`. | |
| is_except_0_fupd_finally | Iris.isExcept0_fupd_finally | |
| lc_fupd_add_later | Iris.lc_fupd_add_later | |
| lc_fupd_add_laterN | Iris.lc_fupd_add_laterN | |
| lc_fupd_add_step_fupdN | Iris.lc_fupd_add_step_fupdN | |
| lc_fupd_elim_later | Iris.lc_fupd_elim_later | |
| step_fupdN_fupd_finally | Iris.step_fupdN_fupd_finally | |
| step_fupdN_soundness | Iris.step_fupdN_soundness | |
| step_fupdN_soundness' | Iris.step_fupdN_soundness_close | |
| subG_invΣ | Superseded by Lean's direct `ElemG` typeclass synthesis. | |
| uPred_bi_bupd_fupd | Iris.instBIUpdateFUpdateIProp | |
| uPred_bi_fupd | Iris.uPred_bi_fupd | |
| uPred_bi_fupd_sbi_no_lc | Iris.uPred_bi_fupd_plainly_no_lc | |
| uPred_fupd | Iris.uPred_fupd | |
| uPred_fupd_aux | `uPred_fupd` is defined directly without `seal`/`unseal`. | |
| uPred_fupd_def | `uPred_fupd` is defined directly without `seal`/`unseal`. | |
| uPred_fupd_mixin | The `BiFUpdMixin` laws are supplied directly when building `uPred_bi_fupd` below. | |
| uPred_fupd_unseal | `uPred_fupd` is defined directly without `seal`/`unseal`. |
| Rocq Name | Status | Details |
|---|---|---|
| fupd | Iris.fupd_vs |
| Rocq Name | Status | Details |
|---|---|---|
| frame_pointsto | ||
| meta_aux | ||
| meta_def | ||
| meta_token_aux | ||
| meta_token_def | ||
| meta_token_unseal | ||
| meta_unseal | ||
| pointsto_aux | ||
| pointsto_combine_as | ||
| pointsto_combine_sep_gives | ||
| pointsto_def | ||
| pointsto_persistent | ||
| pointsto_unseal | ||
| combine_sep_gives_meta_meta_token_1 | Iris.instCombineSepGivesMetaMetaToken1 | |
| combine_sep_gives_meta_meta_token_2 | Iris.instCombineSepGivesMetaMetaToken2 | |
| gen_heapGS | Iris.genHeapGS | |
| gen_heapGpreS | Iris.genHeapPreS | |
| gen_heap_alloc | Iris.genHeap_alloc | |
| gen_heap_alloc_big | Iris.genHeap_alloc_big | |
| gen_heap_init | Iris.genHeap_init | |
| gen_heap_init_names | Iris.genHeap_init_names | |
| gen_heap_interp | Iris.genHeapInterp | |
| gen_heap_update | Iris.genHeap_update | |
| gen_heap_valid | Iris.genHeap_valid | |
| gen_heapΣ | Subsumed by BundledGFunctors typeclass synthesis | |
| meta | Iris.metaInfo | |
| meta_agree | Iris.meta_agree | |
| meta_meta_token_valid | Iris.meta_metaToken_valid | |
| meta_meta_token_valid' | Iris.meta_metaToken_valid' | |
| meta_persistent | Iris.instPersistentMeta | |
| meta_set | Iris.meta_set | |
| meta_timeless | Iris.instTimelessMeta | |
| meta_token | Iris.metaToken | |
| meta_token_combine_as | Iris.instCombineSepGivesMetaToken | |
| meta_token_difference | Iris.metaToken_difference | |
| meta_token_ne | Iris.metaToken_ne | |
| meta_token_timeless | Iris.instTimelessMetaToken | |
| meta_token_union | Iris.metaToken_union | |
| meta_token_union_1 | Iris.metaToken_union_1 | |
| meta_token_union_2 | Iris.metaToken_union_2 | |
| meta_token_valid_2 | Iris.metaToken_valid_2 | |
| pointsto | Iris.pointsTo | |
| pointsto_agree | Iris.pointsTo_agree | |
| pointsto_as_fractional | Iris.instAsFractionalPointsTo | |
| pointsto_combine | Iris.pointsTo_combine | |
| pointsto_frac_ne | Iris.pointsTo_frac_ne | |
| pointsto_fractional | Iris.instFractionalPointsTo | |
| pointsto_ne | Iris.pointsTo_ne | |
| pointsto_persist | Iris.pointsTo_persist | |
| pointsto_timeless | Iris.instTimelessPointsTo | |
| pointsto_unpersist | Iris.pointsTo_unpersist | |
| pointsto_valid | Iris.pointsTo_cmraValid | |
| pointsto_valid_2 | Iris.pointsTo_op_cmraValid | |
| subG_gen_heapGpreS | Subsumed by BundledGFunctors typeclass synthesis |
| Rocq Name | Status | Details |
|---|---|---|
| inv_heapGS | ||
| inv_heapGpreS | ||
| inv_heapN | ||
| inv_heap_init | ||
| inv_heap_inv | ||
| inv_heap_inv_P | ||
| inv_heap_inv_persistent | ||
| inv_heap_mapUR | ||
| inv_heapΣ | ||
| inv_pointsto | ||
| inv_pointsto_acc | ||
| inv_pointsto_lookup_Some | ||
| inv_pointsto_own | ||
| inv_pointsto_own_acc | ||
| inv_pointsto_own_acc_strong | ||
| inv_pointsto_own_inv | ||
| inv_pointsto_own_lookup_Some | ||
| inv_pointsto_own_proper | ||
| inv_pointsto_own_timeless | ||
| inv_pointsto_persistent | ||
| inv_pointsto_proper | ||
| inv_pointsto_timeless | ||
| lookup_to_inv_heap_None | ||
| lookup_to_inv_heap_Some | ||
| lookup_to_inv_heap_Some_2 | ||
| make_inv_pointsto | ||
| subG_inv_heapGpreS | ||
| to_inv_heap | ||
| to_inv_heap_insert | ||
| to_inv_heap_singleton | ||
| to_inv_heap_valid |
| Rocq Name | Status | Details |
|---|---|---|
| ghost_mapG | Iris.GhostMapG | |
| ghost_map_alloc | Iris.ghost_map_alloc | |
| ghost_map_alloc_empty | Iris.ghost_map_alloc_empty | |
| ghost_map_alloc_strong | Iris.ghost_map_alloc_strong | |
| ghost_map_alloc_strong_empty | Iris.ghost_map_alloc_strong_empty | |
| ghost_map_auth | Iris.ghost_map_auth | |
| ghost_map_auth_agree | Iris.ghost_map_auth_agree | |
| ghost_map_auth_as_fractional | Iris.instAsFractionalIPropGhost_map_authOwn | |
| ghost_map_auth_aux | Not needed | |
| ghost_map_auth_def | Not needed | |
| ghost_map_auth_fractional | Iris.ghost_map_auth_fractional | |
| ghost_map_auth_persist | Iris.ghost_map_auth_persist | |
| ghost_map_auth_timeless | Iris.instTimelessIPropGhost_map_auth | |
| ghost_map_auth_unpersist | Iris.ghost_map_auth_unpersist | |
| ghost_map_auth_unseal | Not needed | |
| ghost_map_auth_valid | Iris.ghost_map_auth_valid | |
| ghost_map_auth_valid_2 | Iris.ghost_map_auth_valid_2 | |
| ghost_map_delete | Iris.ghost_map_delete | |
| ghost_map_delete_big | Iris.ghost_map_delete_big | |
| ghost_map_elem | Iris.ghost_map_elem | |
| ghost_map_elem_agree | Iris.ghost_map_elem_agree | |
| ghost_map_elem_as_fractional | Iris.instAsFractionalIPropGhost_map_elemOwn | |
| ghost_map_elem_aux | Not needed | |
| ghost_map_elem_combine | Iris.ghost_map_elem_combine | |
| ghost_map_elem_combine_as | Iris.ghost_map_elem_combine_as | |
| ghost_map_elem_combine_gives | Iris.ghost_map_elem_combine_gives | |
| ghost_map_elem_def | Not needed | |
| ghost_map_elem_frac_ne | Iris.ghost_map_elem_frac_ne | |
| ghost_map_elem_fractional | Iris.ghost_map_elem_fractional | |
| ghost_map_elem_ne | Iris.ghost_map_elem_ne | |
| ghost_map_elem_persist | Iris.ghost_map_elem_persist | |
| ghost_map_elem_persistent | Iris.instPersistentIPropGhost_map_elemDiscard | |
| ghost_map_elem_timeless | Iris.instTimelessIPropGhost_map_elem | |
| ghost_map_elem_unpersist | Iris.ghost_map_elem_unpersist | |
| ghost_map_elem_unseal | Not needed | |
| ghost_map_elem_valid | Iris.ghost_map_elem_valid | |
| ghost_map_elem_valid_2 | Iris.ghost_map_elem_valid_2 | |
| ghost_map_elems_unseal | Iris.ghost_map_elems_unseal | |
| ghost_map_insert | Iris.ghost_map_insert | |
| ghost_map_insert_big | Iris.ghost_map_insert_big | |
| ghost_map_insert_persist | Iris.ghost_map_insert_persist | |
| ghost_map_insert_persist_big | Iris.ghost_map_insert_persist_big | |
| ghost_map_lookup | Iris.ghost_map_lookup | |
| ghost_map_lookup_big | Iris.ghost_map_lookup_big | |
| ghost_map_lookup_combine_gives_1 | Iris.ghost_map_lookup_combine_gives_1 | |
| ghost_map_lookup_combine_gives_2 | Iris.ghost_map_lookup_combine_gives_2 | |
| ghost_map_persistent | Iris.instTimelessIPropGhost_map_authDiscard | |
| ghost_map_update | Iris.ghost_map_update | |
| ghost_map_update_big | Iris.ghost_map_update_big | |
| ghost_mapΣ | Subsumed by BundledGFunctors typeclass synthesis | |
| subG_ghost_mapΣ | Subsumed by BundledGFunctors typeclass synthesis |
| Rocq Name | Status | Details |
|---|---|---|
| frame_ghost_var | ||
| ghost_var | ||
| ghost_varG | ||
| ghost_var_agree | ||
| ghost_var_alloc | ||
| ghost_var_alloc_strong | ||
| ghost_var_as_fractional | ||
| ghost_var_aux | ||
| ghost_var_combine_as | ||
| ghost_var_combine_gives | ||
| ghost_var_def | ||
| ghost_var_fractional | ||
| ghost_var_persist | ||
| ghost_var_persistent | ||
| ghost_var_split | ||
| ghost_var_timeless | ||
| ghost_var_unpersist | ||
| ghost_var_unseal | ||
| ghost_var_update | ||
| ghost_var_update_2 | ||
| ghost_var_update_halves | ||
| ghost_var_valid_2 | ||
| ghost_varΣ | ||
| subG_ghost_varΣ |
| Rocq Name | Status | Details |
|---|---|---|
| gset_bijG | ||
| gset_bij_elem_of | ||
| gset_bij_own_alloc | ||
| gset_bij_own_alloc_empty | ||
| gset_bij_own_auth | ||
| gset_bij_own_auth_agree | ||
| gset_bij_own_auth_as_fractional | ||
| gset_bij_own_auth_aux | ||
| gset_bij_own_auth_def | ||
| gset_bij_own_auth_eq | ||
| gset_bij_own_auth_exclusive | ||
| gset_bij_own_auth_fractional | ||
| gset_bij_own_auth_persistent | ||
| gset_bij_own_auth_timeless | ||
| gset_bij_own_elem | ||
| gset_bij_own_elem_agree | ||
| gset_bij_own_elem_aux | ||
| gset_bij_own_elem_def | ||
| gset_bij_own_elem_eq | ||
| gset_bij_own_elem_get | ||
| gset_bij_own_elem_get_big | ||
| gset_bij_own_elem_persistent | ||
| gset_bij_own_elem_timeless | ||
| gset_bij_own_extend | ||
| gset_bij_own_extend_internal | ||
| gset_bij_own_valid | ||
| gset_bijΣ | ||
| subG_gset_bijΣ |
| Rocq Name | Status | Details |
|---|---|---|
| into_acc_inv | ||
| into_inv_inv | ||
| inv_proper | ||
| except_0_inv | Iris.except_0_inv | |
| fresh_inv_name | fresh_name | |
| inv | Iris.inv | |
| inv_acc | Iris.inv_acc | |
| inv_acc_strong | Iris.inv_acc_strong | |
| inv_acc_timeless | Iris.inv_acc_timeless | |
| inv_alloc | Iris.inv_alloc | |
| inv_alloc_open | Iris.inv_alloc_open | |
| inv_alter | Iris.inv_alter | |
| inv_aux | `inv` is defined directly without `seal`/`unseal`. | |
| inv_combine | Iris.inv_combine | |
| inv_combine_dup_l | Iris.inv_combine_dup_l | |
| inv_contractive | Iris.inv_contractive | |
| inv_def | `inv` is defined directly without `seal`/`unseal`. | |
| inv_iff | Iris.inv_iff | |
| inv_ne | Iris.inv_ne | |
| inv_persistent | Iris.inv_persistent | |
| inv_split | Iris.inv_split | |
| inv_split_l | Iris.inv_split_l | |
| inv_split_r | Iris.inv_split_r | |
| inv_unseal | `inv` is defined directly without `seal`/`unseal`. | |
| is_except_0_inv | Iris.is_except_0_inv | |
| own_inv | Iris.own_inv | |
| own_inv_acc | Iris.own_inv_acc | |
| own_inv_alloc | Iris.own_inv_alloc | |
| own_inv_alloc_open | Iris.own_inv_alloc_open | |
| own_inv_to_inv | Iris.own_inv_to_inv |
| Rocq Name | Status | Details |
|---|---|---|
| iProp_solution.iProp_fold_unfold | ||
| iProp_solution.iProp_unfold_fold | ||
| iProp_unfold_equivI | ||
| gFunctor | Iris.GFunctor | |
| gFunctors | Iris.BundledGFunctors | |
| gFunctors.app | `BundledGFunctors` is a function `GType → GFunctor`; no list combinators. | |
| gFunctors.nil | `BundledGFunctors` is a function `GType → GFunctor`; no list combinators. | |
| gFunctors.singleton | `BundledGFunctors` is a function `GType → GFunctor`; no list combinators. | |
| gid | Use `GType` (= `Nat`) to index `BundledGFunctors` directly. | |
| gname | Iris.GName | |
| gnameO | Use `LeibnizO GName`. | |
| iProp_solution.iPrePropO | Iris.IPre | |
| iProp_solution.iPreProp_cofe | Iris.instCOFEIPre | |
| iProp_solution.iProp_fold | Iris.IProp.fold | |
| iProp_solution.iProp_result | Iris.IPre | |
| iProp_solution.iProp_unfold | Iris.IProp.unfold | |
| iProp_solution.iResUR | Iris.IResUR | |
| iResF | Iris.IResF | |
| iResUR | Sealed copy of `iProp_solution.iResUR`; not needed since Lean does not seal it. | |
| subG | Superseded by `ElemG`. | |
| subG_app_l | Lemma about `subG`; obsolete with `ElemG`. | |
| subG_app_r | Lemma about `subG`; obsolete with `ElemG`. | |
| subG_inv | Lemma about `subG`; obsolete with `ElemG`. | |
| subG_refl | Lemma about `subG`; obsolete with `ElemG`. |
| Rocq Name | Status | Details |
|---|---|---|
| le_upd.le_upd_equiv_proper | ||
| le_upd.le_upd_flip_mono' | ||
| le_upd.le_upd_mono' | ||
| combine_sep_lc_S_l | Not necessary in Lean as it is more common to use +1 instead of .succ | |
| combine_sep_lc_add | Iris.instCombineSepAsIPropLcHAddCredit | |
| from_sep_lc_S | Iris.instFromSepIPropLcSuccOfNatCredit | |
| from_sep_lc_add | Iris.instFromSepIPropLcHAddCredit | |
| has_lc | Iris.HasLC | |
| into_sep_lc_S | Iris.instIntoSepIPropLcSuccOfNatCredit | |
| into_sep_lc_add | Iris.instIntoSepIPropLcHAddCredit | |
| lc | Iris.lc | |
| lcGS | Iris.LcGS | |
| lcGpreS | Iris.LcGpreS | |
| lc_0_persistent | Iris.instPersistentIPropLcOfNatCredit | |
| lc_aux | `lc` is defined directly without `seal`/`unseal`. | |
| lc_decrease_supply | Iris.lc_decrease_supply | |
| lc_def | `lc` is defined directly without `seal`/`unseal`. | |
| lc_increase_supply | Iris.lc_increase_supply | |
| lc_no_lc | Iris.lc_no_lc | |
| lc_split | Iris.lc_split | |
| lc_succ | Iris.lc_succ | |
| lc_supply | Iris.lc_supply | |
| lc_supply_aux | `lc_supply` is defined directly without `seal`/`unseal`. | |
| lc_supply_bound | Iris.lc_supply_bound | |
| lc_supply_def | `lc_supply` is defined directly without `seal`/`unseal`. | |
| lc_supply_no_lc | Iris.lc_supply_no_lc | |
| lc_supply_unseal | `lc_supply` is defined directly without `seal`/`unseal`. | |
| lc_timeless | Iris.instTimelessIPropLc | |
| lc_unseal | `lc` is defined directly without `seal`/`unseal`. | |
| lc_weaken | Iris.lc_weaken | |
| lc_zero | Iris.lc_zero | |
| lcΣ | Superseded by the `LcGpreS` typeclass on `BundledGFunctors`. | |
| le_upd.bi_bupd_mixin_le_upd | Only a safety check, not used | |
| le_upd.bupd_le_upd | Iris.bupd_le_upd | |
| le_upd.elim_bupd_le_upd | Iris.instElimModalIPropTrueFalseBupdLe_upd | |
| le_upd.elim_modal_le_upd | Iris.instElimModalIPropTrueFalseLe_upd | |
| le_upd.except_0_le_upd | Iris.except_0_le_upd | |
| le_upd.frame_le_upd | Iris.instFrameIPropLe_upd | |
| le_upd.from_assumption_le_upd | Iris.from_assumption_le_upd | |
| le_upd.from_modal_le_upd | Iris.instFromModalUPredIResURTrueModality_idLe_upd | |
| le_upd.from_pure_le_upd | Iris.instFromPureIPropLe_upd | |
| le_upd.is_except_0_le_upd | Iris.instIsExcept0IPropLe_upd | |
| le_upd.lc_alloc | Iris.lc_alloc | |
| le_upd.lc_alloc_no_lc | Iris.lc_alloc_no_lc | |
| le_upd.lc_le_upd_add_later | Iris.le_upd_later | |
| le_upd.lc_le_upd_elim_later | Iris.le_upd_later_elim | |
| le_upd.lc_soundness | Iris.lc_soundness | |
| le_upd.le_upd | Iris.le_upd | |
| le_upd.le_upd_aux | `le_upd` is defined directly without `seal`/`unseal`. | |
| le_upd.le_upd_bind | Iris.le_upd_bind | |
| le_upd.le_upd_def | `le_upd` is defined directly without `seal`/`unseal`. | |
| le_upd.le_upd_finally | Iris.le_upd_finally | |
| le_upd.le_upd_finally_add_lc | Iris.le_upd_finally_add_lc | |
| le_upd.le_upd_finally_aux | Not needed | |
| le_upd.le_upd_finally_def | Not needed | |
| le_upd.le_upd_finally_except_0 | Iris.le_upd_finally_except0 | |
| le_upd.le_upd_finally_flip_mono' | Subsumed by `le_upd_finally_mono` | |
| le_upd.le_upd_finally_forall | Iris.le_upd_finally_forall | |
| le_upd.le_upd_finally_intro | Iris.le_upd_finally_intro | |
| le_upd.le_upd_finally_later | Iris.le_upd_finally_later | |
| le_upd.le_upd_finally_mono | Iris.le_upd_finally_mono | |
| le_upd.le_upd_finally_mono' | Subsumed by `le_upd_finally_mono` | |
| le_upd.le_upd_finally_ne | Iris.le_upd_finally_ne | |
| le_upd.le_upd_finally_proper | Subsumed by the NonExpansive instance `le_upd_finally_ne` | |
| le_upd.le_upd_finally_soundness | Iris.le_upd_finally_soundness | |
| le_upd.le_upd_finally_unseal | Not needed | |
| le_upd.le_upd_frame_l | Iris.le_upd_frame_l | |
| le_upd.le_upd_frame_r | Iris.le_upd_frame_r | |
| le_upd.le_upd_intro | Iris.le_upd_intro | |
| le_upd.le_upd_keep | Iris.le_upd_keep | |
| le_upd.le_upd_le_upd_finally | Iris.le_upd_le_upd_finally | |
| le_upd.le_upd_mono | Iris.le_upd_mono | |
| le_upd.le_upd_ne | Iris.instNonExpansiveIPropLe_upd | |
| le_upd.le_upd_pre | Iris.le_upd_pre | |
| le_upd.le_upd_pre_contractive | Iris.instContractiveIPropLe_upd_pre | |
| le_upd.le_upd_trans | Iris.le_upd_trans | |
| le_upd.le_upd_unfold | Iris.le_upd_unfold | |
| le_upd.le_upd_unfold_no_le | Iris.le_upd_unfold_no_le | |
| le_upd.le_upd_unseal | `le_upd` is defined directly without `seal`/`unseal`. | |
| subG_lcΣ | Superseded by Lean's direct `ElemG` typeclass synthesis. |
| Rocq Name | Status | Details |
|---|---|---|
| mono_ZG | ||
| mono_Z_auth_lb_own_valid | ||
| mono_Z_auth_own | ||
| mono_Z_auth_own_agree | ||
| mono_Z_auth_own_as_fractional | ||
| mono_Z_auth_own_aux | ||
| mono_Z_auth_own_def | ||
| mono_Z_auth_own_exclusive | ||
| mono_Z_auth_own_fractional | ||
| mono_Z_auth_own_persistent | ||
| mono_Z_auth_own_timeless | ||
| mono_Z_auth_own_unseal | ||
| mono_Z_lb_own | ||
| mono_Z_lb_own_0 | ||
| mono_Z_lb_own_aux | ||
| mono_Z_lb_own_def | ||
| mono_Z_lb_own_get | ||
| mono_Z_lb_own_le | ||
| mono_Z_lb_own_persistent | ||
| mono_Z_lb_own_timeless | ||
| mono_Z_lb_own_unseal | ||
| mono_Z_own_alloc | ||
| mono_Z_own_persist | ||
| mono_Z_own_unpersist | ||
| mono_Z_own_update | ||
| mono_ZΣ |
| Rocq Name | Status | Details |
|---|---|---|
| mono_listG | ||
| mono_list_auth_idx_lookup | ||
| mono_list_auth_lb_own_valid | ||
| mono_list_auth_own | ||
| mono_list_auth_own_agree | ||
| mono_list_auth_own_as_fractional | ||
| mono_list_auth_own_aux | ||
| mono_list_auth_own_def | ||
| mono_list_auth_own_exclusive | ||
| mono_list_auth_own_fractional | ||
| mono_list_auth_own_persist | ||
| mono_list_auth_own_persistent | ||
| mono_list_auth_own_timeless | ||
| mono_list_auth_own_unpersist | ||
| mono_list_auth_own_unseal | ||
| mono_list_auth_own_update | ||
| mono_list_auth_own_update_app | ||
| mono_list_idx_agree | ||
| mono_list_idx_own | ||
| mono_list_idx_own_get | ||
| mono_list_idx_own_persistent | ||
| mono_list_idx_own_timeless | ||
| mono_list_lb_own | ||
| mono_list_lb_own_aux | ||
| mono_list_lb_own_def | ||
| mono_list_lb_own_get | ||
| mono_list_lb_own_le | ||
| mono_list_lb_own_nil | ||
| mono_list_lb_own_persistent | ||
| mono_list_lb_own_timeless | ||
| mono_list_lb_own_unseal | ||
| mono_list_lb_own_valid | ||
| mono_list_own_alloc | ||
| mono_listΣ | ||
| subG_mono_listΣ |
| Rocq Name | Status | Details |
|---|---|---|
| mono_nat_auth_own_as_fractional | ||
| mono_nat_auth_own_aux | ||
| mono_nat_auth_own_def | ||
| mono_nat_auth_own_unseal | ||
| mono_nat_lb_own_aux | ||
| mono_nat_lb_own_def | ||
| mono_nat_lb_own_unseal | ||
| mono_natΣ | ||
| subG_mono_natΣ | ||
| mono_natG | Iris.MonoNatG | |
| mono_nat_auth_lb_own_valid | Iris.MonoNat.auth_lb_own_valid | |
| mono_nat_auth_own | Iris.MonoNat.auth_own | |
| mono_nat_auth_own_agree | Iris.MonoNat.auth_own_agree | |
| mono_nat_auth_own_exclusive | Iris.MonoNat.auth_own_exclusive | |
| mono_nat_auth_own_fractional | Iris.MonoNat.instFractionalIPropAuth_ownOwn | |
| mono_nat_auth_own_persistent | Iris.MonoNat.instPersistentIPropAuth_ownDiscard | |
| mono_nat_auth_own_timeless | Iris.MonoNat.instTimelessIPropAuth_own | |
| mono_nat_lb_own | Iris.MonoNat.lb_own | |
| mono_nat_lb_own_0 | Iris.MonoNat.lb_own_0 | |
| mono_nat_lb_own_get | Iris.MonoNat.lb_own_get | |
| mono_nat_lb_own_le | Iris.MonoNat.lb_own_le | |
| mono_nat_lb_own_persistent | Iris.MonoNat.instPersistentIPropLb_own | |
| mono_nat_lb_own_timeless | Iris.MonoNat.instTimelessIPropLb_own | |
| mono_nat_own_alloc | Iris.MonoNat.own_alloc | |
| mono_nat_own_alloc_strong | Iris.MonoNat.own_alloc_strong | |
| mono_nat_own_persist | Iris.MonoNat.own_persist | |
| mono_nat_own_unpersist | Iris.MonoNat.own_unpersist | |
| mono_nat_own_update | Iris.MonoNat.own_update |
| Rocq Name | Status | Details |
|---|---|---|
| into_acc_na | ||
| into_inv_na | ||
| na_inv_proper | ||
| na_alloc | Iris.NonAtomicInvariant.alloc | |
| na_inv | Iris.NonAtomicInvariant.inv | |
| na_invG | Iris.NaInvG | |
| na_inv_acc | Iris.NonAtomicInvariant.inv_acc | |
| na_inv_alloc | Iris.NonAtomicInvariant.inv_alloc | |
| na_inv_contractive | Iris.NonAtomicInvariant.instContractive_inv | |
| na_inv_iff | Iris.NonAtomicInvariant.inv_iff | |
| na_inv_ne | Iris.NonAtomicInvariant.instNonExpansive_inv | |
| na_inv_persistent | Iris.NonAtomicInvariant.instPersistentInv | |
| na_inv_pool_name | Iris.NaInvPoolName | |
| na_invΣ | Superseded by the `NaInvG` typeclass on `BundledGFunctors`. | |
| na_own | Iris.NonAtomicInvariant.own | |
| na_own_acc | Iris.NonAtomicInvariant.own_acc | |
| na_own_disjoint | Iris.NonAtomicInvariant.own_disjoint | |
| na_own_empty | Iris.NonAtomicInvariant.own_empty | |
| na_own_empty_persistent | Iris.NonAtomicInvariant.instPersistent_own | |
| na_own_timeless | Iris.NonAtomicInvariant.instTimeless_own | |
| na_own_union | Iris.NonAtomicInvariant.own_union | |
| subG_na_invG | Superseded by Lean's direct `ElemG` typeclass synthesis. |
| Rocq Name | Status | Details |
|---|---|---|
| big_opMS_own | ||
| big_opMS_own_1 | ||
| iRes_project | ||
| iRes_project_above | ||
| iRes_project_below | ||
| iRes_project_ne | ||
| iRes_project_op | ||
| iRes_project_singleton | ||
| iRes_singleton_validI | ||
| later_internal_eq_iRes_singleton | ||
| later_own | ||
| own_and | ||
| own_and_discrete_total | ||
| own_and_discrete_total_False | ||
| own_and_total | ||
| own_eq | ||
| own_forall | ||
| own_forall_pred | ||
| own_forall_pred_total | ||
| own_forall_total | ||
| own_mono' | ||
| own_proper | ||
| big_opL_own | Iris.bigOpL_iOwn | |
| big_opL_own_1 | Iris.bigOpL_iOwn_entail | |
| big_opM_own | Iris.bigOpM_iOwn | |
| big_opM_own_1 | Iris.bigOpM_iOwn_entail | |
| big_opS_own | Iris.bigOpS_iOwn | |
| big_opS_own_1 | Iris.bigOpS_iOwn_entail | |
| combine_sep_as_own | Iris.combineSepAs_iOwn | |
| combine_sep_gives_own | Iris.combineSepGives_iOwn | |
| from_and_own_persistent | Iris.fromAndOwn_persistent | |
| from_sep_own | Iris.fromSep_own | |
| iRes_singleton | Iris.iSingleton | |
| iRes_singleton_core_id | Iris.instCoreIdIResURISingletonOfApIProp | |
| iRes_singleton_discrete | Iris.iSingleton_discreteE | |
| iRes_singleton_ne | Iris.instNonExpansiveApIPropIResURISingleton | |
| iRes_singleton_op | Iris.iSingleton_op | |
| inG | Iris.ElemG | |
| inG_fold | Iris.IProp.foldi | |
| inG_fold_unfold | Iris.IProp.foldi_unfoldi | |
| inG_unfold | Iris.IProp.unfoldi | |
| inG_unfold_fold | Iris.IProp.unfoldi_foldi | |
| inG_unfold_validN | Iris.IProp.validN_unfoldi | |
| into_and_own | Iris.intoAnd_own | |
| into_sep_own | Iris.intoSep_own | |
| own | Iris.iOwn | |
| own_alloc | Iris.iOwn_alloc | |
| own_alloc_cofinite | Iris.iOwn_alloc_cofinite | |
| own_alloc_cofinite_dep | Iris.iOwn_alloc_cofinite_dep | |
| own_alloc_dep | Iris.iOwn_alloc_dep | |
| own_alloc_strong | Iris.iOwn_alloc_strong | |
| own_alloc_strong_dep | Iris.iOwn_alloc_strong_dep | |
| own_aux | `iOwn` is defined directly without `seal`/`unseal`. | |
| own_cmra_sep_entails_homomorphism | Iris.iOwn_cmra_sep_entails_homomorphism | |
| own_cmra_sep_homomorphism | Iris.iOwn_cmra_sep_homomorphism | |
| own_core_persistent | Iris.instPersistentIPropIOwnOfCoreIdAp | |
| own_def | `iOwn` is defined directly without `seal`/`unseal`. | |
| own_mono | Iris.iOwn_mono | |
| own_ne | Iris.iOwn_ne | |
| own_op | Iris.iOwn_op | |
| own_timeless | Iris.iOwn_timeless | |
| own_unit | Iris.iOwn_unit | |
| own_update | Iris.iOwn_update | |
| own_updateP | Iris.iOwn_updateP | |
| own_update_2 | Iris.iOwn_update_op | |
| own_update_3 | Iris.iOwn_update_op_op | |
| own_valid | Iris.iOwn_cmraValid | |
| own_valid_2 | Iris.iOwn_cmraValid_op | |
| own_valid_3 | Iris.iOwn_cmraValid_op_op | |
| own_valid_l | Iris.iOwn_valid_l | |
| own_valid_r | Iris.iOwn_valid_r | |
| subG_inG | Superseded by Lean's direct `ElemG` typeclass synthesis. |
| Rocq Name | Status | Details |
|---|---|---|
| proph | Iris.proph | |
| proph_aux | Not needed | |
| proph_def | Not needed | |
| proph_exclusive | Iris.proph_exclusive | |
| proph_list_resolves | Iris.prophListResolves | |
| proph_mapGS | Iris.prophMapGS | |
| proph_mapGpreS | Iris.prophMapPreS | |
| proph_map_agree | Iris.ProphMap.agree | |
| proph_map_init | Iris.ProphMap.init | |
| proph_map_interp | Iris.prophMapInterp | |
| proph_map_new_proph | Iris.ProphMap.new_proph | |
| proph_map_resolve_proph | Iris.ProphMap.resolve_proph | |
| proph_mapΣ | Subsumed by BundledGFunctors typeclass synthesis | |
| proph_resolves_in_list | Iris.prophResolvesInList | |
| proph_timeless | Iris.instTimelessProph | |
| proph_unseal | Not needed | |
| proph_val_list | Iris.ProphValList | |
| resolves_insert | Iris.resolves_insert | |
| subG_proph_mapGpreS | Subsumed by BundledGFunctors typeclass synthesis |
| Rocq Name | Status | Details |
|---|---|---|
| savedAnythingG | ||
| savedAnythingΣ | ||
| saved_anything_agree | ||
| saved_anything_alloc | ||
| saved_anything_alloc_cofinite | ||
| saved_anything_alloc_strong | ||
| saved_anything_as_fractional | ||
| saved_anything_combine_as | ||
| saved_anything_combine_gives | ||
| saved_anything_discarded_persistent | ||
| saved_anything_fractional | ||
| saved_anything_ne | ||
| saved_anything_own | ||
| saved_anything_persist | ||
| saved_anything_proper | ||
| saved_anything_unpersist | ||
| saved_anything_update | ||
| saved_anything_update_2 | ||
| saved_anything_update_halves | ||
| saved_anything_valid | ||
| saved_anything_valid_2 | ||
| saved_pred_agree | ||
| saved_pred_alloc | ||
| saved_pred_alloc_cofinite | ||
| saved_pred_alloc_strong | ||
| saved_pred_as_fractional | ||
| saved_pred_discarded_persistent | ||
| saved_pred_fractional | ||
| saved_pred_own | ||
| saved_pred_own_contractive | ||
| saved_pred_persist | ||
| saved_pred_unpersist | ||
| saved_pred_update | ||
| saved_pred_update_2 | ||
| saved_pred_update_halves | ||
| saved_pred_valid | ||
| saved_pred_valid_2 | ||
| saved_prop_agree | ||
| saved_prop_alloc | ||
| saved_prop_alloc_cofinite | ||
| saved_prop_alloc_strong | ||
| saved_prop_as_fractional | ||
| saved_prop_discarded_persistent | ||
| saved_prop_fractional | ||
| saved_prop_own | ||
| saved_prop_own_contractive | ||
| saved_prop_persist | ||
| saved_prop_unpersist | ||
| saved_prop_update | ||
| saved_prop_update_2 | ||
| saved_prop_update_halves | ||
| saved_prop_valid | ||
| saved_prop_valid_2 | ||
| subG_savedAnythingΣ |
| Rocq Name | Status | Details |
|---|---|---|
| tokenΣ | ||
| subG_tokenΣ | Superseded by Lean's direct `ElemG` typeclass synthesis. | |
| tokenG | Iris.TokenG | |
| token_alloc | Iris.token_alloc | |
| token_alloc_strong | Iris.token_alloc_strong | |
| token_aux | `token` is defined directly without `seal`/`unseal`. | |
| token_combine_gives | Iris.instCombineSepGivesIPropTokenPureFalse | |
| token_def | `token` is defined directly without `seal`/`unseal`. | |
| token_exclusive | Iris.token_exclusive | |
| token_timeless | Iris.token_timeless | |
| token_unseal | `token` is defined directly without `seal`/`unseal`. |
| Rocq Name | Status | Details |
|---|---|---|
| invariant_lookup | Iris.invariant_lookup | |
| invariant_unfold | Iris.invariant_unfold | |
| invariant_unfold_contractive | Only needed for ownI_contractive which is proved directly | |
| ownD | Iris.ownD | |
| ownD_disjoint | Iris.ownD_disjoint | |
| ownD_empty | Iris.ownD_empty | |
| ownD_op | Iris.ownD_op | |
| ownD_op' | Iris.ownD_op_iff | |
| ownD_singleton_twice | Iris.ownD_singleton_twice | |
| ownE | Iris.ownE | |
| ownE_disjoint | Iris.ownE_disjoint | |
| ownE_empty | Iris.ownE_empty | |
| ownE_op | Iris.ownE_op | |
| ownE_op' | Iris.ownE_op_iff | |
| ownE_singleton_twice | Iris.ownE_singleton_twice | |
| ownI | Iris.ownI | |
| ownI_alloc | Iris.ownI_alloc | |
| ownI_alloc_open | Iris.ownI_alloc_open | |
| ownI_close | Iris.ownI_close | |
| ownI_contractive | Iris.instContractiveIPropOwnI | |
| ownI_open | Iris.ownI_open | |
| ownI_persistent | Iris.instPersistentIPropOwnI | |
| wsat | Iris.wsat | |
| wsatGS.subG_wsatΣ | Superseded by Lean's direct `ElemG` typeclass synthesis. | |
| wsatGS.wsatGS | Iris.WsatGS | |
| wsatGS.wsatGpreS | Iris.WsatGpreS | |
| wsatGS.wsatΣ | Superseded by the `WsatGpreS` typeclass on `BundledGFunctors`. | |
| wsat_alloc | Iris.wsat_alloc |
| Rocq Name | Status | Details |
|---|---|---|
| combine_sep_as_ownM | ||
| combine_sep_gives_ownM | ||
| from_sep_ownM | ||
| from_sep_ownM_core_id | ||
| into_and_ownM | ||
| into_sep_ownM |
| Rocq Name | Status | Details |
|---|---|---|
| uPredO_map_ne | ||
| uPred_alt | ||
| uPred_map_compose | ||
| uPred_map_ext | ||
| uPred_map_id | ||
| uPred_map_ne | ||
| uPred_primitive.entails_anti_sym | ||
| uPred_primitive.equiv_entails | ||
| uPred_primitive.persistently_elim | ||
| uPred | Iris.UPred | |
| uPredO | Iris.instOFEUPred | |
| uPredOF | Iris.instOFunctorUPredOF | |
| uPredOF_contractive | Iris.instUPredOFunctorContractive | |
| uPredO_map | Iris.uPred_map | |
| uPred_and | UPred.and | |
| uPred_and_aux | `UPred.and` is defined directly without `seal`/`unseal`. | |
| uPred_and_def | `UPred.and` is defined directly without `seal`/`unseal`. | |
| uPred_and_unseal | `UPred.and` is defined directly without `seal`/`unseal`. | |
| uPred_bupd | UPred.bupd | |
| uPred_bupd_aux | `UPred.bupd` is defined directly without `seal`/`unseal`. | |
| uPred_bupd_def | `UPred.bupd` is defined directly without `seal`/`unseal`. | |
| uPred_bupd_unseal | `UPred.bupd` is defined directly without `seal`/`unseal`. | |
| uPred_cofe | Iris.instIsCOFEUPred | |
| uPred_compl | Inlined in the `IsCOFE` construction | |
| uPred_dist | Not needed | |
| uPred_dist' | Inlined in the `OFE` construction | |
| uPred_entails | UPred.Entails | |
| uPred_equiv | Not needed | |
| uPred_equiv' | Inlined in the `OFE` construction | |
| uPred_exist | UPred.sExists | |
| uPred_exist_aux | `UPred.sExists` is defined directly without `seal`/`unseal`. | |
| uPred_exist_def | `UPred.sExists` is defined directly without `seal`/`unseal`. | |
| uPred_exist_unseal | `UPred.sExists` is defined directly without `seal`/`unseal`. | |
| uPred_forall | UPred.sForall | |
| uPred_forall_aux | `UPred.sForall` is defined directly without `seal`/`unseal`. | |
| uPred_forall_def | `UPred.sForall` is defined directly without `seal`/`unseal`. | |
| uPred_forall_unseal | `UPred.sForall` is defined directly without `seal`/`unseal`. | |
| uPred_holds_ne | Iris.uPred_holds_ne | |
| uPred_impl | UPred.imp | |
| uPred_impl_aux | `UPred.imp` is defined directly without `seal`/`unseal`. | |
| uPred_impl_def | `UPred.imp` is defined directly without `seal`/`unseal`. | |
| uPred_impl_unseal | `UPred.imp` is defined directly without `seal`/`unseal`. | |
| uPred_later | UPred.later | |
| uPred_later_aux | `UPred.later` is defined directly without `seal`/`unseal`. | |
| uPred_later_def | `UPred.later` is defined directly without `seal`/`unseal`. | |
| uPred_later_unseal | `UPred.later` is defined directly without `seal`/`unseal`. | |
| uPred_map | Inlined in `uPred_map` | |
| uPred_ne | Iris.uPred_ne | |
| uPred_ofe_mixin | Not needed | |
| uPred_or | UPred.or | |
| uPred_or_aux | `UPred.or` is defined directly without `seal`/`unseal`. | |
| uPred_or_def | `UPred.or` is defined directly without `seal`/`unseal`. | |
| uPred_or_unseal | `UPred.or` is defined directly without `seal`/`unseal`. | |
| uPred_ownM | UPred.ownM | |
| uPred_ownM_aux | `UPred.ownM` is defined directly without `seal`/`unseal`. | |
| uPred_ownM_def | `UPred.ownM` is defined directly without `seal`/`unseal`. | |
| uPred_ownM_unseal | `UPred.ownM` is defined directly without `seal`/`unseal`. | |
| uPred_persistently | UPred.persistently | |
| uPred_persistently_aux | `UPred.persistently` is defined directly without `seal`/`unseal`. | |
| uPred_persistently_def | `UPred.persistently` is defined directly without `seal`/`unseal`. | |
| uPred_persistently_unseal | `UPred.persistently` is defined directly without `seal`/`unseal`. | |
| uPred_primitive.True_sep_1 | Inlined in `uPredI` construction | |
| uPred_primitive.True_sep_2 | Inlined in `uPredI` construction | |
| uPred_primitive.and_elim_l | Inlined in `uPredI` construction | |
| uPred_primitive.and_elim_r | Inlined in `uPredI` construction | |
| uPred_primitive.and_intro | Inlined in `uPredI` construction | |
| uPred_primitive.and_ne | Inlined in `uPredI` construction | |
| uPred_primitive.bupd_frame_r | Inlined in BIUpdate instance construction | |
| uPred_primitive.bupd_intro | Inlined in BIUpdate instance construction | |
| uPred_primitive.bupd_mono | Inlined in BIUpdate instance construction | |
| uPred_primitive.bupd_ne | UPred.bupd_ne | |
| uPred_primitive.bupd_ownM_updateP | UPred.bupd_ownM_updateP | |
| uPred_primitive.bupd_si_pure | UPred.bupd_si_pure | |
| uPred_primitive.bupd_trans | Inlined in BIUpdate instance construction | |
| uPred_primitive.entails_lim | UPred.uPred_entails_lim | |
| uPred_primitive.entails_po | UPred.uPred_entails_preorder | |
| uPred_primitive.exist_elim | Inlined in `uPredI` construction | |
| uPred_primitive.exist_intro | Inlined in `uPredI` construction | |
| uPred_primitive.exist_ne | Inlined in `uPredI` construction | |
| uPred_primitive.forall_elim | Inlined in `uPredI` construction | |
| uPred_primitive.forall_intro | Inlined in `uPredI` construction | |
| uPred_primitive.forall_ne | Inlined in `uPredI` construction | |
| uPred_primitive.impl_elim_l' | Inlined in `uPredI` construction | |
| uPred_primitive.impl_intro_r | Inlined in `uPredI` construction | |
| uPred_primitive.impl_ne | Inlined in `uPredI` construction | |
| uPred_primitive.later_contractive | UPred.later_contractive | |
| uPred_primitive.later_exist_false | Inlined in `uPredI` construction | |
| uPred_primitive.later_false_em | Inlined in `uPredI` construction | |
| uPred_primitive.later_forall_2 | Inlined in `uPredI` construction | |
| uPred_primitive.later_intro | Inlined in `uPredI` construction | |
| uPred_primitive.later_mono | Inlined in `uPredI` construction | |
| uPred_primitive.later_ownM | UPred.later_ownM | |
| uPred_primitive.later_persistently_1 | Inlined in `uPredI` construction | |
| uPred_primitive.later_persistently_2 | Inlined in `uPredI` construction | |
| uPred_primitive.later_sep_1 | Inlined in `uPredI` construction | |
| uPred_primitive.later_sep_2 | Inlined in `uPredI` construction | |
| uPred_primitive.or_elim | Inlined in `uPredI` construction | |
| uPred_primitive.or_intro_l | Inlined in `uPredI` construction | |
| uPred_primitive.or_intro_r | Inlined in `uPredI` construction | |
| uPred_primitive.or_ne | Inlined in `uPredI` construction | |
| uPred_primitive.ownM_forall | UPred.ownM_forall | |
| uPred_primitive.ownM_ne | UPred.ownM_ne | |
| uPred_primitive.ownM_op | UPred.ownM_op | |
| uPred_primitive.ownM_unit | UPred.ownM_unit | |
| uPred_primitive.ownM_valid | UPred.ownM_valid | |
| uPred_primitive.persistently_and_sep_l_1 | Inlined in `uPredI` construction | |
| uPred_primitive.persistently_exist_1 | Inlined in `uPredI` construction | |
| uPred_primitive.persistently_forall_2 | Inlined in `BIPersistentlyForall` construction | |
| uPred_primitive.persistently_idemp_2 | Inlined in `uPredI` construction | |
| uPred_primitive.persistently_impl_si_pure | UPred.persistently_imp_uPredSiPure | |
| uPred_primitive.persistently_mono | Inlined in `uPredI` construction | |
| uPred_primitive.persistently_ne | UPred.persistently_ne | |
| uPred_primitive.persistently_ownM_core | UPred.persistently_ownM_core | |
| uPred_primitive.prop_ext_2 | UPred.prop_ext_uPredSiEmpValid | |
| uPred_primitive.sep_assoc' | Inlined in `uPredI` construction | |
| uPred_primitive.sep_comm' | Inlined in `uPredI` construction | |
| uPred_primitive.sep_mono | Inlined in `uPredI` construction | |
| uPred_primitive.sep_ne | Inlined in `uPredI` construction | |
| uPred_primitive.si_emp_valid_exist_1 | UPred.uPredSiEmpValid_exist_mp | |
| uPred_primitive.si_emp_valid_later_1 | UPred.uPredSiEmpValid_later_mp | |
| uPred_primitive.si_emp_valid_mono | UPred.uPredSiEmpValid_mono | |
| uPred_primitive.si_emp_valid_ne | UPred.uPredSiEmpValid_ne | |
| uPred_primitive.si_emp_valid_si_pure | UPred.uPredSiEmpValid_uPredSiPure | |
| uPred_primitive.si_pure_forall_2 | UPred.uPredSiPure_forall_mpr | |
| uPred_primitive.si_pure_impl_2 | UPred.uPredSiPure_imp_mpr | |
| uPred_primitive.si_pure_later | UPred.uPredSiPure_later | |
| uPred_primitive.si_pure_mono | UPred.uPredSiPure_mono | |
| uPred_primitive.si_pure_ne | UPred.uPredSiPure_ne | |
| uPred_primitive.si_pure_si_emp_valid | UPred.uPredSiPure_uPredSiEmpValid | |
| uPred_primitive.uPred_unseal | No `Ltac unseal` rewrite is needed; nothing is sealed. | |
| uPred_primitive.wand_elim_l' | Inlined in `uPredI` construction | |
| uPred_primitive.wand_intro_r | Inlined in `uPredI` construction | |
| uPred_primitive.wand_ne | Inlined in `uPredI` construction | |
| uPred_proper | Iris.uPred_proper | |
| uPred_sep | UPred.sep | |
| uPred_sep_aux | `UPred.sep` is defined directly without `seal`/`unseal`. | |
| uPred_sep_def | `UPred.sep` is defined directly without `seal`/`unseal`. | |
| uPred_sep_unseal | `UPred.sep` is defined directly without `seal`/`unseal`. | |
| uPred_si_emp_valid | UPred.uPredSiEmpValid | |
| uPred_si_emp_valid_aux | `UPred.uPredSiEmpValid` is defined directly without `seal`/`unseal`. | |
| uPred_si_emp_valid_def | `UPred.uPredSiEmpValid` is defined directly without `seal`/`unseal`. | |
| uPred_si_emp_valid_unseal | `UPred.uPredSiEmpValid` is defined directly without `seal`/`unseal`. | |
| uPred_si_pure | UPred.uPredSiPure | |
| uPred_si_pure_aux | `UPred.uPredSiPure` is defined directly without `seal`/`unseal`. | |
| uPred_si_pure_def | `UPred.uPredSiPure` is defined directly without `seal`/`unseal`. | |
| uPred_si_pure_unseal | `UPred.uPredSiPure` is defined directly without `seal`/`unseal`. | |
| uPred_wand | UPred.wand | |
| uPred_wand_aux | `UPred.wand` is defined directly without `seal`/`unseal`. | |
| uPred_wand_def | `UPred.wand` is defined directly without `seal`/`unseal`. | |
| uPred_wand_unseal | `UPred.wand` is defined directly without `seal`/`unseal`. |
▶
bi/1459/2280 (64%)| Rocq Name | Status | Details |
|---|---|---|
| Some_included_totalI | ||
| cmra_later_opI | ||
| cmra_morphism_validI | ||
| cmra_validI_op_l | ||
| cmra_validI_op_r | ||
| csum_includedI | ||
| csum_validI | ||
| dfrac_agree_validI | ||
| dfrac_agree_validI_2 | ||
| discrete_fun_validI | ||
| excl_auth_agreeI | ||
| excl_includedI | ||
| excl_validI | ||
| f_homom_includedI | ||
| frac_agree_validI | ||
| frac_agree_validI_2 | ||
| gmap_equivI | ||
| gmap_union_equiv_eqI | ||
| gmap_validI | ||
| id_freeI_l | ||
| id_freeI_r | ||
| list_equivI | ||
| option_includedI | ||
| option_included_totalI | ||
| option_validI | ||
| prod_includedI | ||
| prod_validI | ||
| singleton_validI | ||
| ucmra_unit_validI | ||
| view_auth_dfrac_validI | ||
| view_auth_validI | ||
| view_both_dfrac_validI | ||
| view_both_dfrac_validI_1 | ||
| view_both_dfrac_validI_2 | ||
| view_both_validI | ||
| view_both_validI_1 | ||
| view_both_validI_2 | ||
| view_frag_validI | ||
| agree_equivI | Iris.agree_equivI | |
| agree_includedI | Iris.agree_includedI | |
| agree_op_equiv_to_agreeI | Iris.agree_op_equiv_toAgreeI | |
| agree_op_invI | Iris.agree_op_invI | |
| auth_auth_dfrac_op_validI | Iris.auth_dfrac_op_validI | |
| auth_auth_dfrac_validI | Iris.auth_dfrac_validI | |
| auth_auth_validI | Iris.auth_validI | |
| auth_both_dfrac_validI | Iris.both_dfrac_validI | |
| auth_both_validI | Iris.auth_both_validI | |
| auth_frag_validI | Iris.frag_validI | |
| gmap_view_both_dfrac_validI | Iris.auth_op_frag_validI | |
| gmap_view_both_validI | Iris.auth_op_frag_one_validI | |
| gmap_view_both_validI_total | Iris.auth_op_frag_validI_total | |
| gmap_view_frag_op_validI | Iris.frag_op_frag_validI | |
| to_agree_includedI | Iris.toAgree_includedI | |
| to_agree_op_validI | Iris.toAgree_op_validI | |
| to_agree_uninjI | Iris.toAgree_uninjI | |
| to_agree_validI | Iris.toAgree_validI |
| Rocq Name | Status | Details |
|---|---|---|
| big_andL_zip_seqZ | ||
| big_andM_kmap | ||
| big_andM_map_seq | ||
| big_andM_map_seqZ | ||
| big_orL_zip_seqZ | ||
| big_sepL_sepM | ||
| big_sepL_sepMS | ||
| big_sepL_sepS | ||
| big_sepL_zip_seqZ | ||
| big_sepM2 | ||
| big_sepM2_affine | ||
| big_sepM2_affine' | ||
| big_sepM2_affinely_pure_2 | ||
| big_sepM2_alt | ||
| big_sepM2_alt_lookup | ||
| big_sepM2_and | ||
| big_sepM2_aux | ||
| big_sepM2_closed | ||
| big_sepM2_def | ||
| big_sepM2_delete | ||
| big_sepM2_delete_l | ||
| big_sepM2_delete_r | ||
| big_sepM2_dom | ||
| big_sepM2_empty | ||
| big_sepM2_empty' | ||
| big_sepM2_empty_affine | ||
| big_sepM2_empty_l | ||
| big_sepM2_empty_persistent | ||
| big_sepM2_empty_r | ||
| big_sepM2_empty_timeless | ||
| big_sepM2_flip | ||
| big_sepM2_flip_mono' | ||
| big_sepM2_fmap | ||
| big_sepM2_fmap_l | ||
| big_sepM2_fmap_r | ||
| big_sepM2_forall | ||
| big_sepM2_fst_snd | ||
| big_sepM2_impl | ||
| big_sepM2_insert | ||
| big_sepM2_insert_2 | ||
| big_sepM2_insert_acc | ||
| big_sepM2_insert_delete | ||
| big_sepM2_intro | ||
| big_sepM2_laterN_2 | ||
| big_sepM2_later_1 | ||
| big_sepM2_later_2 | ||
| big_sepM2_lookup | ||
| big_sepM2_lookup_acc | ||
| big_sepM2_lookup_acc_impl | ||
| big_sepM2_lookup_iff | ||
| big_sepM2_lookup_l | ||
| big_sepM2_lookup_r | ||
| big_sepM2_mono | ||
| big_sepM2_mono' | ||
| big_sepM2_ne | ||
| big_sepM2_ne' | ||
| big_sepM2_ne_2 | ||
| big_sepM2_persistent | ||
| big_sepM2_persistent' | ||
| big_sepM2_persistently | ||
| big_sepM2_proper | ||
| big_sepM2_proper' | ||
| big_sepM2_proper_2 | ||
| big_sepM2_pure | ||
| big_sepM2_pure_1 | ||
| big_sepM2_sep | ||
| big_sepM2_sepM | ||
| big_sepM2_sepM_2 | ||
| big_sepM2_sep_2 | ||
| big_sepM2_singleton | ||
| big_sepM2_timeless | ||
| big_sepM2_timeless' | ||
| big_sepM2_union_inv_l | ||
| big_sepM2_union_inv_r | ||
| big_sepM2_unseal | ||
| big_sepM2_wand | ||
| big_sepMS_affine | ||
| big_sepMS_affine' | ||
| big_sepMS_affinely_pure_2 | ||
| big_sepMS_and | ||
| big_sepMS_delete | ||
| big_sepMS_disj_union | ||
| big_sepMS_dup | ||
| big_sepMS_elem_of | ||
| big_sepMS_elem_of_acc | ||
| big_sepMS_elem_of_acc_impl | ||
| big_sepMS_empty | ||
| big_sepMS_empty' | ||
| big_sepMS_empty_affine | ||
| big_sepMS_empty_persistent | ||
| big_sepMS_empty_timeless | ||
| big_sepMS_flip_mono' | ||
| big_sepMS_forall | ||
| big_sepMS_impl | ||
| big_sepMS_insert | ||
| big_sepMS_intro | ||
| big_sepMS_later | ||
| big_sepMS_laterN | ||
| big_sepMS_laterN_2 | ||
| big_sepMS_later_2 | ||
| big_sepMS_mono | ||
| big_sepMS_mono' | ||
| big_sepMS_ne | ||
| big_sepMS_persistent | ||
| big_sepMS_persistent' | ||
| big_sepMS_persistently | ||
| big_sepMS_proper | ||
| big_sepMS_pure | ||
| big_sepMS_pure_1 | ||
| big_sepMS_sep | ||
| big_sepMS_sepL | ||
| big_sepMS_sepM | ||
| big_sepMS_sepMS | ||
| big_sepMS_sepS | ||
| big_sepMS_sep_2 | ||
| big_sepMS_singleton | ||
| big_sepMS_subseteq | ||
| big_sepMS_timeless | ||
| big_sepMS_timeless' | ||
| big_sepMS_wand | ||
| big_sepM_gset_to_gmap | ||
| big_sepM_kmap | ||
| big_sepM_map_seq | ||
| big_sepM_map_seqZ | ||
| big_sepM_sepL | ||
| big_sepM_sepM | ||
| big_sepM_sepM2_diag | ||
| big_sepM_sepMS | ||
| big_sepM_sepS | ||
| big_sepM_set_to_map | ||
| big_sepS_sepMS | ||
| big_andL_absorbing | Iris.BI.BigAndL.bigAndL_absorbing | |
| big_andL_absorbing' | Iris.BI.BigAndL.bigAndL_absorbing_inst | |
| big_andL_and | Iris.BI.BigAndL.bigAndL_and_eqv | |
| big_andL_app | Iris.BI.BigAndL.bigAndL_append | |
| big_andL_bind | Iris.BI.BigAndL.bigAndL_flatMap | |
| big_andL_cons | Iris.BI.BigAndL.bigAndL_cons | |
| big_andL_elem_of | Iris.BI.BigAndL.bigAndL_mem | |
| big_andL_fmap | Iris.BI.BigAndL.bigAndL_map | |
| big_andL_forall | Iris.BI.BigAndL.bigAndL_forall | |
| big_andL_id_mono' | Iris.BI.BigAndL.bigAndL_id_mono_of_forall | |
| big_andL_impl | Iris.BI.BigAndL.bigAndL_impl | |
| big_andL_intro | Iris.BI.BigAndL.bigAndL_intro | |
| big_andL_later | Iris.BI.BigAndL.bigAndL_later | |
| big_andL_laterN | Iris.BI.BigAndL.bigAndL_laterN | |
| big_andL_lookup | Iris.BI.BigAndL.bigAndL_lookup | |
| big_andL_mono | Iris.BI.BigAndL.bigAndL_mono | |
| big_andL_mono' | Iris.BI.BigAndL.bigAndL_mono_of_forall | |
| big_andL_ne | Iris.BI.BigAndL.bigAndL_dist | |
| big_andL_nil | Iris.BI.BigAndL.bigAndL_nil | |
| big_andL_nil' | Iris.BI.BigAndL.bigAndL_nil_intro | |
| big_andL_nil_absorbing | Iris.BI.BigAndL.bigAndL_nil_absorbing_inst | |
| big_andL_nil_persistent | Iris.BI.BigAndL.bigAndL_nil_persistent_inst | |
| big_andL_nil_timeless | Iris.BI.BigAndL.bigAndL_nil_timeless_inst | |
| big_andL_persistent | Iris.BI.BigAndL.bigAndL_persistent | |
| big_andL_persistent' | Iris.BI.BigAndL.bigAndL_persistent_inst | |
| big_andL_persistently | Iris.BI.BigAndL.bigAndL_persistently | |
| big_andL_proper | Iris.BI.BigAndL.bigAndL_eqv | |
| big_andL_pure | Iris.BI.BigAndL.bigAndL_pure | |
| big_andL_pure_1 | Iris.BI.BigAndL.bigAndL_pure_intro | |
| big_andL_pure_2 | Iris.BI.BigAndL.bigAndL_pure_elim | |
| big_andL_singleton | Iris.BI.BigAndL.bigAndL_singleton | |
| big_andL_snoc | Iris.BI.BigAndL.bigAndL_snoc | |
| big_andL_submseteq | Iris.BI.BigAndL.bigAndL_submseteq | |
| big_andL_timeless | Iris.BI.BigAndL.bigAndL_timeless | |
| big_andL_timeless' | Iris.BI.BigAndL.bigAndL_timeless_inst | |
| big_andL_zip_seq | Iris.BI.BigAndL.bigAndL_zip_seq | |
| big_andM_and | Iris.BI.BigAndM.bigAndM_and_eqv | |
| big_andM_delete | Iris.BI.BigAndM.bigAndM_delete | |
| big_andM_empty | Iris.BI.BigAndM.bigAndM_empty | |
| big_andM_empty' | Iris.BI.BigAndM.bigAndM_empty_intro | |
| big_andM_empty_persistent | Iris.BI.BigAndM.bigAndM_nil_persistent_inst | |
| big_andM_empty_timeless | Iris.BI.BigAndM.bigAndM_nil_timeless_inst | |
| big_andM_filter | Iris.BI.BigAndM.bigAndM_filter | |
| big_andM_filter' | Iris.BI.BigAndM.bigAndM_filter_cond | |
| big_andM_fmap | Iris.BI.BigAndM.bigAndM_map | |
| big_andM_fn_insert | Iris.BI.BigAndM.bigAndM_fn_insert | |
| big_andM_fn_insert' | Iris.BI.BigAndM.bigAndM_fn_insert_cond | |
| big_andM_forall | Iris.BI.BigAndM.bigAndM_forall | |
| big_andM_impl | Iris.BI.BigAndM.bigAndM_impl | |
| big_andM_insert | Iris.BI.BigAndM.bigAndM_insert | |
| big_andM_insert_2 | Iris.BI.BigAndM.bigAndM_insert_elim | |
| big_andM_insert_delete | Iris.BI.BigAndM.bigAndM_insert_delete | |
| big_andM_intro | Iris.BI.BigAndM.bigAndM_intro | |
| big_andM_later | Iris.BI.BigAndM.bigAndM_later | |
| big_andM_laterN | Iris.BI.BigAndM.bigAndM_laterN | |
| big_andM_lookup | Iris.BI.BigAndM.bigAndM_lookup | |
| big_andM_lookup_dom | Iris.BI.BigAndM.bigAndM_lookup_dom | |
| big_andM_mono | Iris.BI.BigAndM.bigAndM_mono | |
| big_andM_mono' | Iris.BI.BigAndM.bigAndM_mono_of_forall | |
| big_andM_ne | Iris.BI.BigAndM.bigAndM_dist | |
| big_andM_omap | Iris.BI.BigAndM.bigAndM_filterMap | |
| big_andM_persistent | Iris.BI.BigAndM.bigAndM_persistent | |
| big_andM_persistent' | Iris.BI.BigAndM.bigAndM_persistent_inst | |
| big_andM_persistently | Iris.BI.BigAndM.bigAndM_persistently | |
| big_andM_proper | Iris.BI.BigAndM.bigAndM_eqv | |
| big_andM_pure | Iris.BI.BigAndM.bigAndM_pure | |
| big_andM_pure_1 | Iris.BI.BigAndM.bigAndM_pure_intro | |
| big_andM_pure_2 | Iris.BI.BigAndM.bigAndM_pure_elim | |
| big_andM_singleton | Iris.BI.BigAndM.bigAndM_singleton | |
| big_andM_subseteq | Iris.BI.BigAndM.bigAndM_subseteq | |
| big_andM_timeless | Iris.BI.BigAndM.bigAndM_timeless | |
| big_andM_timeless' | Iris.BI.BigAndM.bigAndM_timeless_inst | |
| big_andM_union | Iris.BI.BigAndM.bigAndM_union | |
| big_orL_app | Iris.BI.BigOrL.bigOrL_append | |
| big_orL_bind | Iris.BI.BigOrL.bigOrL_flatMap | |
| big_orL_cons | Iris.BI.BigOrL.bigOrL_cons | |
| big_orL_elem_of | Iris.BI.BigOrL.bigOrL_mem | |
| big_orL_exist | Iris.BI.BigOrL.bigOrL_exist | |
| big_orL_fmap | Iris.BI.BigOrL.bigOrL_map | |
| big_orL_id_mono' | Iris.BI.BigOrL.bigOrL_id_mono_of_forall | |
| big_orL_intro | Iris.BI.BigOrL.bigOrL_intro | |
| big_orL_later | Iris.BI.BigOrL.bigOrL_later | |
| big_orL_laterN | Iris.BI.BigOrL.bigOrL_laterN | |
| big_orL_mono | Iris.BI.BigOrL.bigOrL_mono | |
| big_orL_mono' | Iris.BI.BigOrL.bigOrL_mono_of_forall | |
| big_orL_ne | Iris.BI.BigOrL.bigOrL_dist | |
| big_orL_nil | Iris.BI.BigOrL.bigOrL_nil | |
| big_orL_nil_persistent | Iris.BI.BigOrL.bigOrL_nil_persistent | |
| big_orL_nil_timeless | Iris.BI.BigOrL.bigOrL_nil_timeless | |
| big_orL_or | Iris.BI.BigOrL.bigOrL_or_eqv | |
| big_orL_persistent | Iris.BI.BigOrL.bigOrL_persistent | |
| big_orL_persistent' | Iris.BI.BigOrL.bigOrL_persistent_inst | |
| big_orL_persistently | Iris.BI.BigOrL.bigOrL_persistently | |
| big_orL_proper | Iris.BI.BigOrL.bigOrL_eqv | |
| big_orL_pure | Iris.BI.BigOrL.bigOrL_pure | |
| big_orL_sep_l | Iris.BI.BigOrL.bigOrL_sep_left | |
| big_orL_sep_r | Iris.BI.BigOrL.bigOrL_sep_right | |
| big_orL_singleton | Iris.BI.BigOrL.bigOrL_singleton | |
| big_orL_snoc | Iris.BI.BigOrL.bigOrL_snoc | |
| big_orL_submseteq | Iris.BI.BigOrL.bigOrL_submseteq | |
| big_orL_timeless | Iris.BI.BigOrL.bigOrL_timeless | |
| big_orL_timeless' | Iris.BI.BigOrL.bigOrL_timeless_inst | |
| big_orL_zip_seq | Iris.BI.BigOrL.bigOrL_zip_seq | |
| big_sepL2 | Iris.BI.bigSepL2 | |
| big_sepL2_affine | Iris.BI.BigSepL2.bigSepL2_affine | |
| big_sepL2_affine' | Iris.BI.BigSepL2.bigSepL2_affine_inst | |
| big_sepL2_affinely_pure_2 | Iris.BI.BigSepL2.bigSepL2_affinely_pure_elim | |
| big_sepL2_alt | Iris.BI.BigSepL2.bigSepL2_alt | |
| big_sepL2_and | Iris.BI.BigSepL2.bigSepL2_and | |
| big_sepL2_app | Iris.BI.BigSepL2.bigSepL2_app_wand | |
| big_sepL2_app_inv | Iris.BI.BigSepL2.bigSepL2_append | |
| big_sepL2_app_inv_l | Iris.BI.BigSepL2.bigSepL2_app_inv_left | |
| big_sepL2_app_inv_r | Iris.BI.BigSepL2.bigSepL2_app_inv_right | |
| big_sepL2_app_same_length | Iris.BI.BigSepL2.bigSepL2_app_same_length | |
| big_sepL2_closed | Iris.BI.BigSepL2.bigSepL2_closed | |
| big_sepL2_cons | Iris.BI.BigSepL2.bigSepL2_cons | |
| big_sepL2_cons_inv_l | Iris.BI.BigSepL2.bigSepL2_cons_inv_left | |
| big_sepL2_cons_inv_r | Iris.BI.BigSepL2.bigSepL2_cons_inv_right | |
| big_sepL2_const_sepL_l | Iris.BI.BigSepL2.bigSepL2_const_sepL_left | |
| big_sepL2_const_sepL_r | Iris.BI.BigSepL2.bigSepL2_const_sepL_right | |
| big_sepL2_delete | Iris.BI.BigSepL2.bigSepL2_delete_cond | |
| big_sepL2_delete' | Iris.BI.BigSepL2.bigSepL2_delete | |
| big_sepL2_flip | Iris.BI.BigSepL2.bigSepL2_flip | |
| big_sepL2_flip_mono' | Iris.BI.BigSepL2.bigSepL2_mono_of_forall | |
| big_sepL2_fmap_l | Iris.BI.BigSepL2.bigSepL2_map_left | |
| big_sepL2_fmap_r | Iris.BI.BigSepL2.bigSepL2_map_right | |
| big_sepL2_forall | Iris.BI.BigSepL2.bigSepL2_forall | |
| big_sepL2_fst_snd | Iris.BI.BigSepL2.bigSepL2_fst_snd | |
| big_sepL2_impl | Iris.BI.BigSepL2.bigSepL2_impl | |
| big_sepL2_insert_acc | Iris.BI.BigSepL2.bigSepL2_insert_acc | |
| big_sepL2_intro | Iris.BI.BigSepL2.bigSepL2_intro | |
| big_sepL2_laterN_2 | Iris.BI.BigSepL2.bigSepL2_laterN_2 | |
| big_sepL2_later_1 | Iris.BI.BigSepL2.bigSepL2_later_1 | |
| big_sepL2_later_2 | Iris.BI.BigSepL2.bigSepL2_later_2 | |
| big_sepL2_length | Iris.BI.BigSepL2.bigSepL2_length | |
| big_sepL2_lookup | Iris.BI.BigSepL2.bigSepL2_lookup | |
| big_sepL2_lookup_acc | Iris.BI.BigSepL2.bigSepL2_lookup_acc | |
| big_sepL2_lookup_acc_impl | Iris.BI.BigSepL2.bigSepL2_lookup_acc_impl | |
| big_sepL2_lookup_l | Iris.BI.BigSepL2.bigSepL2_lookup_left | |
| big_sepL2_lookup_r | Iris.BI.BigSepL2.bigSepL2_lookup_right | |
| big_sepL2_mono | Iris.BI.BigSepL2.bigSepL2_mono | |
| big_sepL2_mono' | Use BigSepL2.bigSepL2_mono directly. | |
| big_sepL2_ne | Iris.BI.BigSepL2.bigSepL2_dist | |
| big_sepL2_ne' | bigSepL2 is preserved under ≡ by nonexpansivity. | |
| big_sepL2_ne_2 | Iris.BI.BigSepL2.bigSepL2_dist_2 | |
| big_sepL2_nil | Iris.BI.BigSepL2.bigSepL2_nil | |
| big_sepL2_nil' | Iris.BI.BigSepL2.bigSepL2_nil_affine | |
| big_sepL2_nil_affine | Iris.BI.BigSepL2.bigSepL2_nil_affine_inst | |
| big_sepL2_nil_inv_l | Iris.BI.BigSepL2.bigSepL2_nil_inv_left | |
| big_sepL2_nil_inv_r | Iris.BI.BigSepL2.bigSepL2_nil_inv_right | |
| big_sepL2_nil_persistent | Iris.BI.BigSepL2.bigSepL2_nil_persistent_inst | |
| big_sepL2_nil_timeless | Iris.BI.BigSepL2.bigSepL2_nil_timeless | |
| big_sepL2_persistent | Iris.BI.BigSepL2.bigSepL2_persistent | |
| big_sepL2_persistent' | Iris.BI.BigSepL2.bigSepL2_persistent_inst | |
| big_sepL2_persistently | Iris.BI.BigSepL2.bigSepL2_persistently | |
| big_sepL2_proper | Iris.BI.BigSepL2.bigSepL2_eqv | |
| big_sepL2_proper' | bigSepL2 is preserved under ⊣⊢. | |
| big_sepL2_proper_2 | Iris.BI.BigSepL2.bigSepL2_proper_2 | |
| big_sepL2_pure | Iris.BI.BigSepL2.bigSepL2_pure | |
| big_sepL2_pure_1 | Iris.BI.BigSepL2.bigSepL2_pure_intro | |
| big_sepL2_replicate_l | Iris.BI.BigSepL2.bigSepL2_replicate_left | |
| big_sepL2_replicate_r | Iris.BI.BigSepL2.bigSepL2_replicate_right | |
| big_sepL2_reverse | Iris.BI.BigSepL2.bigSepL2_reverse | |
| big_sepL2_reverse_2 | Iris.BI.BigSepL2.bigSepL2_reverse_2 | |
| big_sepL2_sep | Iris.BI.BigSepL2.bigSepL2_sep_eqv | |
| big_sepL2_sepL | Iris.BI.BigSepL2.bigSepL2_sepL | |
| big_sepL2_sepL_2 | Iris.BI.BigSepL2.bigSepL2_sepL_2 | |
| big_sepL2_sep_2 | Iris.BI.BigSepL2.bigSepL2_sep_eqv_symm | |
| big_sepL2_sep_sepL_l | Iris.BI.BigSepL2.bigSepL2_sep_sepL_left | |
| big_sepL2_sep_sepL_r | Iris.BI.BigSepL2.bigSepL2_sep_sepL_right | |
| big_sepL2_singleton | Iris.BI.BigSepL2.bigSepL2_singleton | |
| big_sepL2_snoc | Iris.BI.BigSepL2.bigSepL2_snoc | |
| big_sepL2_timeless | Iris.BI.BigSepL2.bigSepL2_timeless | |
| big_sepL2_timeless' | Iris.BI.BigSepL2.bigSepL2_timeless' | |
| big_sepL2_wand | Iris.BI.BigSepL2.bigSepL2_wand | |
| big_sepL_affine | Iris.BI.BigSepL.bigSepL_affine | |
| big_sepL_affine' | Iris.BI.BigSepL.bigSepL_affine_inst | |
| big_sepL_affine_id | Iris.BI.BigSepL.bigSepL_affine_id | |
| big_sepL_affinely_pure_2 | Iris.BI.BigSepL.bigSepL_affinely_pure_elim | |
| big_sepL_and | Iris.BI.BigSepL.bigSepL_and | |
| big_sepL_app | Iris.BI.BigSepL.bigSepL_append | |
| big_sepL_bind | Iris.BI.BigSepL.bigSepL_flatMap | |
| big_sepL_cons | Iris.BI.BigSepL.bigSepL_cons | |
| big_sepL_delete | Iris.BI.BigSepL.bigSepL_delete_cond | |
| big_sepL_delete' | Iris.BI.BigSepL.bigSepL_delete | |
| big_sepL_dup | Iris.BI.BigSepL.bigSepL_dup | |
| big_sepL_elem_of | Iris.BI.BigSepL.bigSepL_mem | |
| big_sepL_elem_of_acc | Iris.BI.BigSepL.bigSepL_mem_acc | |
| big_sepL_emp | Iris.BI.BigSepL.bigSepL_emp | |
| big_sepL_flip_mono' | Iris.BI.BigSepL.bigSepL_flip_mono | |
| big_sepL_fmap | Iris.BI.BigSepL.bigSepL_map | |
| big_sepL_forall | Iris.BI.BigSepL.bigSepL_forall_eqv | |
| big_sepL_id_mono' | Iris.BI.BigSepL.bigSepL_id_mono | |
| big_sepL_impl | Iris.BI.BigSepL.bigSepL_impl | |
| big_sepL_insert_acc | Iris.BI.BigSepL.bigSepL_insert_acc | |
| big_sepL_intro | Iris.BI.BigSepL.bigSepL_intro | |
| big_sepL_later | Iris.BI.BigSepL.bigSepL_later | |
| big_sepL_laterN | Iris.BI.BigSepL.bigSepL_laterN | |
| big_sepL_laterN_2 | Iris.BI.BigSepL.bigSepL_laterN_2 | |
| big_sepL_later_2 | Iris.BI.BigSepL.bigSepL_later_2 | |
| big_sepL_lookup | Iris.BI.BigSepL.bigSepL_lookup | |
| big_sepL_lookup_acc | Iris.BI.BigSepL.bigSepL_lookup_acc | |
| big_sepL_lookup_acc_impl | Iris.BI.BigSepL.bigSepL_lookup_acc_impl | |
| big_sepL_mono | Iris.BI.BigSepL.bigSepL_mono | |
| big_sepL_mono' | Use BigSepL.bigSepL_mono directly. | |
| big_sepL_ne | Iris.BI.BigSepL.bigSepL_dist | |
| big_sepL_nil | Iris.BI.BigSepL.bigSepL_nil | |
| big_sepL_nil' | Iris.BI.BigSepL.bigSepL_nil_intro | |
| big_sepL_nil_affine | Iris.BI.BigSepL.bigSepL_nil_affine_inst | |
| big_sepL_nil_persistent | Iris.BI.BigSepL.bigSepL_nil_persistent | |
| big_sepL_nil_timeless | Iris.BI.BigSepL.bigSepL_nil_timeless_inst | |
| big_sepL_omap | Iris.BI.BigSepL.bigSepL_filterMap | |
| big_sepL_persistent | Iris.BI.BigSepL.bigSepL_persistent | |
| big_sepL_persistent' | Iris.BI.BigSepL.bigSepL_persistent_inst | |
| big_sepL_persistent_id | Iris.BI.BigSepL.bigSepL_persistent_id | |
| big_sepL_persistently | Iris.BI.BigSepL.bigSepL_persistently | |
| big_sepL_proper | Iris.BI.BigSepL.bigSepL_eqv | |
| big_sepL_pure | Iris.BI.BigSepL.bigSepL_pure | |
| big_sepL_pure_1 | Iris.BI.BigSepL.bigSepL_pure_intro | |
| big_sepL_replicate | Iris.BI.BigSepL.bigSepL_replicate | |
| big_sepL_sep | Iris.BI.BigSepL.bigSepL_sep_eqv | |
| big_sepL_sepL | Iris.BI.BigSepL.bigSepL_comm | |
| big_sepL_sepL2_diag | Iris.BI.BigSepL2.bigSepL_sepL2_diag | |
| big_sepL_sep_2 | Iris.BI.BigSepL.bigSepL_sep_eqv_symm | |
| big_sepL_sep_zip | Iris.BI.BigSepL.bigSepL_sep_zip | |
| big_sepL_sep_zip_with | Iris.BI.BigSepL.bigSepL_sep_zip_with | |
| big_sepL_singleton | Iris.BI.BigSepL.bigSepL_singleton | |
| big_sepL_snoc | Iris.BI.BigSepL.bigSepL_snoc | |
| big_sepL_submseteq | Iris.BI.BigSepL.bigSepL_submseteq | |
| big_sepL_take_drop | Iris.BI.BigSepL.bigSepL_take_drop | |
| big_sepL_timeless | Iris.BI.BigSepL.bigSepL_timeless | |
| big_sepL_timeless' | Iris.BI.BigSepL.bigSepL_timeless_inst | |
| big_sepL_timeless_id | Iris.BI.BigSepL.bigSepL_timeless_id | |
| big_sepL_wand | Iris.BI.BigSepL.bigSepL_wand | |
| big_sepL_zip_seq | Iris.BI.BigSepL.bigSepL_zip_seq | |
| big_sepL_zip_with | Iris.BI.BigSepL.bigSepL_zip_with | |
| big_sepM_affine | Iris.BI.BigSepM.bigSepM_affine | |
| big_sepM_affine' | Iris.BI.BigSepM.bigSepM_affine_inst | |
| big_sepM_affinely_pure_2 | Iris.BI.BigSepM.bigSepM_affinely_pure_elim | |
| big_sepM_and | Iris.BI.BigSepM.bigSepM_and | |
| big_sepM_delete | Iris.BI.BigSepM.bigSepM_delete | |
| big_sepM_dom | Iris.BI.BigSepM.bigSepM_dom | |
| big_sepM_dup | Iris.BI.BigSepM.bigSepM_dup | |
| big_sepM_empty | Iris.BI.BigSepM.bigSepM_empty | |
| big_sepM_empty' | Iris.BI.BigSepM.bigSepM_empty_intro | |
| big_sepM_empty_affine | Iris.BI.BigSepM.bigSepM_nil_affine_inst | |
| big_sepM_empty_persistent | Iris.BI.BigSepM.bigSepM_nil_persistent_inst | |
| big_sepM_empty_timeless | Iris.BI.BigSepM.bigSepM_nil_timeless_inst | |
| big_sepM_filter | Iris.BI.BigSepM.bigSepM_filter | |
| big_sepM_filter' | Iris.BI.BigSepM.bigSepM_filter_cond | |
| big_sepM_flip_mono' | Iris.BI.BigSepM.bigSepM_flip_mono | |
| big_sepM_fmap | Iris.BI.BigSepM.bigSepM_map | |
| big_sepM_fn_insert | Iris.BI.BigSepM.bigSepM_fn_insert | |
| big_sepM_fn_insert' | Iris.BI.BigSepM.bigSepM_fn_insert_key | |
| big_sepM_forall | Iris.BI.BigSepM.bigSepM_forall | |
| big_sepM_impl | Iris.BI.BigSepM.bigSepM_impl | |
| big_sepM_impl_dom_subseteq | Iris.BI.BigSepM.bigSepM_impl_dom_subseteq | |
| big_sepM_impl_strong | Iris.BI.BigSepM.bigSepM_impl_strong | |
| big_sepM_insert | Iris.BI.BigSepM.bigSepM_insert | |
| big_sepM_insert_2 | Iris.BI.BigSepM.bigSepM_insert_elim | |
| big_sepM_insert_acc | Iris.BI.BigSepM.bigSepM_insert_acc | |
| big_sepM_insert_delete | Iris.BI.BigSepM.bigSepM_insert_delete | |
| big_sepM_insert_override | Iris.BI.BigSepM.bigSepM_insert_exist | |
| big_sepM_insert_override_1 | Iris.BI.BigSepM.bigSepM_insert_exist_elim | |
| big_sepM_insert_override_2 | Iris.BI.BigSepM.bigSepM_insert_exist_intro | |
| big_sepM_intro | Iris.BI.BigSepM.bigSepM_intro | |
| big_sepM_later | Iris.BI.BigSepM.bigSepM_later | |
| big_sepM_laterN | Iris.BI.BigSepM.bigSepM_laterN | |
| big_sepM_laterN_2 | Iris.BI.BigSepM.bigSepM_laterN_2 | |
| big_sepM_later_2 | Iris.BI.BigSepM.bigSepM_later_2 | |
| big_sepM_list_to_map | Iris.BI.BigSepM.bigSepM_ofList | |
| big_sepM_lookup | Iris.BI.BigSepM.bigSepM_lookup | |
| big_sepM_lookup_acc | Iris.BI.BigSepM.bigSepM_lookup_acc | |
| big_sepM_lookup_acc_impl | Iris.BI.BigSepM.bigSepM_lookup_acc_impl | |
| big_sepM_lookup_dom | Iris.BI.BigSepM.bigSepM_lookup_dom | |
| big_sepM_map_to_list | Iris.BI.BigSepM.bigSepM_toList | |
| big_sepM_mono | Iris.BI.BigSepM.bigSepM_mono | |
| big_sepM_mono' | Iris.BI.BigSepM.bigSepM_mono_of_forall | |
| big_sepM_ne | Iris.BI.BigSepM.bigSepM_dist | |
| big_sepM_omap | Iris.BI.BigSepM.bigSepM_filterMap | |
| big_sepM_persistent | Iris.BI.BigSepM.bigSepM_persistent | |
| big_sepM_persistent' | Iris.BI.BigSepM.bigSepM_persistent_inst | |
| big_sepM_persistently | Iris.BI.BigSepM.bigSepM_persistently | |
| big_sepM_proper | Iris.BI.BigSepM.bigSepM_eqv | |
| big_sepM_pure | Iris.BI.BigSepM.bigSepM_pure | |
| big_sepM_pure_1 | Iris.BI.BigSepM.bigSepM_pure_intro | |
| big_sepM_sep | Iris.BI.BigSepM.bigSepM_sep_eqv | |
| big_sepM_sep_2 | Iris.BI.BigSepM.bigSepM_sep_eqv_symm | |
| big_sepM_sep_zip | Iris.BI.BigSepM.bigSepM_sep_zip | |
| big_sepM_sep_zip_with | Iris.BI.BigSepM.bigSepM_sep_zipWith | |
| big_sepM_singleton | Iris.BI.BigSepM.bigSepM_singleton | |
| big_sepM_subseteq | Iris.BI.BigSepM.bigSepM_subseteq | |
| big_sepM_timeless | Iris.BI.BigSepM.bigSepM_timeless | |
| big_sepM_timeless' | Iris.BI.BigSepM.bigSepM_timeless_inst | |
| big_sepM_union | Iris.BI.BigSepM.bigSepM_union | |
| big_sepM_wand | Iris.BI.BigSepM.bigSepM_wand | |
| big_sepS_affine | Iris.BI.BigSepS.bigSepS_affine | |
| big_sepS_affine' | Iris.BI.BigSepS.bigSepS_affine_inst | |
| big_sepS_affinely_pure_2 | Iris.BI.BigSepS.bigSepS_affinely_pure_elim | |
| big_sepS_and | Iris.BI.BigSepS.bigSepS_and | |
| big_sepS_delete | Iris.BI.BigSepS.bigSepS_delete | |
| big_sepS_delete_2 | Iris.BI.BigSepS.bigSepS_delete_elim | |
| big_sepS_dup | Iris.BI.BigSepS.bigSepS_dup | |
| big_sepS_elem_of | Iris.BI.BigSepS.bigSepS_elem_of | |
| big_sepS_elem_of_acc | Iris.BI.BigSepS.bigSepS_elem_of_acc | |
| big_sepS_elem_of_acc_impl | Iris.BI.BigSepS.bigSepS_elem_of_acc_impl | |
| big_sepS_elements | Iris.BI.BigSepS.bigSepS_elements | |
| big_sepS_emp | Iris.BI.BigSepS.bigSepS_emp | |
| big_sepS_empty | Iris.BI.BigSepS.bigSepS_empty | |
| big_sepS_empty' | Iris.BI.BigSepS.bigSepS_empty_intro | |
| big_sepS_empty_affine | Iris.BI.BigSepS.bigSepS_empty_affine_inst | |
| big_sepS_empty_persistent | Iris.BI.BigSepS.bigSepS_empty_persistent_inst | |
| big_sepS_empty_timeless | Iris.BI.BigSepS.bigSepS_empty_timeless_inst | |
| big_sepS_filter | Iris.BI.BigSepS.bigSepS_filter | |
| big_sepS_filter' | Iris.BI.BigSepS.bigSepS_filter_cond | |
| big_sepS_filter_acc | Iris.BI.BigSepS.bigSepS_filter_acc | |
| big_sepS_filter_acc' | Iris.BI.BigSepS.bigSepS_filter_acc_cond | |
| big_sepS_flip_mono' | Iris.BI.BigSepS.bigSepS_flip_mono | |
| big_sepS_fn_insert | Iris.BI.BigSepS.bigSepS_fn_insert | |
| big_sepS_fn_insert' | Iris.BI.BigSepS.bigSepS_fn_insert_key | |
| big_sepS_forall | Iris.BI.BigSepS.bigSepS_forall | |
| big_sepS_impl | Iris.BI.BigSepS.bigSepS_impl | |
| big_sepS_insert | Iris.BI.BigSepS.bigSepS_insert | |
| big_sepS_insert_2 | Iris.BI.BigSepS.bigSepS_insert_elim | |
| big_sepS_insert_2' | Iris.BI.BigSepS.bigSepS_insert_elim_wand | |
| big_sepS_intro | Iris.BI.BigSepS.bigSepS_intro | |
| big_sepS_later | Iris.BI.BigSepS.bigSepS_later | |
| big_sepS_laterN | Iris.BI.BigSepS.bigSepS_laterN | |
| big_sepS_laterN_2 | Iris.BI.BigSepS.bigSepS_laterN_2 | |
| big_sepS_later_2 | Iris.BI.BigSepS.bigSepS_later_2 | |
| big_sepS_list_to_set | Iris.BI.BigSepS.bigSepS_of_list | |
| big_sepS_mono | Iris.BI.BigSepS.bigSepS_mono | |
| big_sepS_mono' | Iris.BI.BigSepS.bigSepS_mono_of_forall | |
| big_sepS_ne | Iris.BI.BigSepS.bigSepS_ne | |
| big_sepS_persistent | Iris.BI.BigSepS.bigSepS_persistent | |
| big_sepS_persistent' | Iris.BI.BigSepS.bigSepS_persistent_inst | |
| big_sepS_persistently | Iris.BI.BigSepS.bigSepS_persistently | |
| big_sepS_proper | Iris.BI.BigSepS.bigSepS_proper | |
| big_sepS_pure | Iris.BI.BigSepS.bigSepS_pure | |
| big_sepS_pure_1 | Iris.BI.BigSepS.bigSepS_pure_intro | |
| big_sepS_sep | Iris.BI.BigSepS.bigSepS_sep | |
| big_sepS_sepL | Iris.BI.BigSepS.bigSepS_comm_list | |
| big_sepS_sepM | Iris.BI.BigSepS.bigSepS_comm_map | |
| big_sepS_sepS | Iris.BI.BigSepS.bigSepS_comm_set | |
| big_sepS_sep_2 | Iris.BI.BigSepS.bigSepS_sep_symm | |
| big_sepS_singleton | Iris.BI.BigSepS.bigSepS_singleton | |
| big_sepS_subseteq | Iris.BI.BigSepS.bigSepS_subseteq | |
| big_sepS_timeless | Iris.BI.BigSepS.bigSepS_timeless | |
| big_sepS_timeless' | Iris.BI.BigSepS.bigSepS_timeless_inst | |
| big_sepS_union | Iris.BI.BigSepS.bigSepS_union | |
| big_sepS_union_2 | Iris.BI.BigSepS.bigSepS_union_elim | |
| big_sepS_wand | Iris.BI.BigSepS.bigSepS_wand |
| Rocq Name | Status | Details |
|---|---|---|
| internal_cmra_valid | Iris.internalCmraValid | |
| internal_cmra_valid_absorbing | Iris.internalCmraValid_absorbing | |
| internal_cmra_valid_discrete | Iris.internalCmraValid_discrete | |
| internal_cmra_valid_elim | Iris.internalCmraValid_elim | |
| internal_cmra_valid_entails | Iris.internalCmraValid_entails | |
| internal_cmra_valid_intro | Iris.internalCmraValid_intro | |
| internal_cmra_valid_ne | Iris.internalCmraValid_ne | |
| internal_cmra_valid_persistent | Iris.internalCmraValid_persistent | |
| internal_cmra_valid_plain | Iris.internalCmraValid_plain | |
| internal_cmra_valid_proper | Derivable from internalCmraValid_ne with NonExpansive.eqv | |
| internal_cmra_valid_timeless | Iris.internalCmraValid_timeless | |
| internal_cmra_valid_weaken | Iris.internalCmraValid_weaken | |
| internal_included | Iris.internalCmraIncluded | |
| internal_included_absorbing | Iris.internalCmraIncluded_absorbing | |
| internal_included_discrete | Iris.internalCmraIncluded_discrete | |
| internal_included_intro | Iris.internalCmraIncluded_intro | |
| internal_included_nonexpansive | Iris.internalCmraIncluded_ne | |
| internal_included_persistent | Iris.internalCmraIncluded_persistent | |
| internal_included_plain | Iris.internalCmraIncluded_plain | |
| internal_included_proper | Derivable from internalCmraIncluded_ne with NonExpansive.eqv | |
| internal_included_refl | Iris.internalCmraIncluded_refl | |
| internal_included_timeless | Iris.internalCmraIncluded_timeless | |
| internal_included_trans | Iris.internalCmraIncluded_trans | |
| intuitionistically_internal_cmra_valid | Iris.intuitionistically_internalCmraValid | |
| intuitionistically_internal_included | Iris.intuitionistically_internalCmraIncluded | |
| persistently_internal_cmra_valid | Iris.persistently_internalCmraValid | |
| persistently_internal_included | Iris.persistently_internalCmraIncluded | |
| plainly_internal_cmra_valid | Iris.plainly_internalCmraValid | |
| plainly_internal_included | Iris.plainly_internalCmraIncluded | |
| si_pure_internal_cmra_valid | Iris.siPure_internalCmraValid | |
| si_pure_internal_included | Iris.siPure_internalCmraIncluded |
| Rocq Name | Status | Details |
|---|---|---|
| bi_wandM | ||
| Absorbing | Iris.BI.Absorbing | |
| Affine | Iris.BI.Affine | |
| Persistent | Iris.BI.Persistent | |
| Timeless | Iris.BI.Timeless | |
| bi_absorbingly | Iris.BI.BIBase.absorbingly | |
| bi_absorbingly_if | Iris.BI.BIBase.absorbinglyIf | |
| bi_affinely | Iris.BI.BIBase.affinely | |
| bi_affinely_if | Iris.BI.BIBase.affinelyIf | |
| bi_except_0 | Iris.BI.BIBase.except0 | |
| bi_iff | Iris.BI.BIBase.iff | |
| bi_intuitionistically | Iris.BI.BIBase.intuitionistically | |
| bi_intuitionistically_if | Iris.BI.BIBase.intuitionisticallyIf | |
| bi_laterN | Iris.BI.BIBase.laterN | |
| bi_persistently_if | Iris.BI.BIBase.persistentlyIf | |
| bi_wand_iff | Iris.BI.BIBase.wandIff |
| Rocq Name | Status | Details |
|---|---|---|
| bi.and_parallel | ||
| bi.bi_or_monoid | ||
| bi.decide_bi_True | ||
| bi.decide_emp | ||
| bi.entails_anti_sym | ||
| bi.entails_impl | ||
| bi.equiv_entails_2 | ||
| bi.equiv_iff | ||
| bi.exist_wand_forall | ||
| bi.from_option_persistent | ||
| bi.iff_equiv | ||
| bi.iff_sym | ||
| bi.iff_trans | ||
| bi.impl_alt | ||
| bi.impl_entails | ||
| bi.impl_wand | ||
| bi.impl_wand_2 | ||
| bi.impl_wand_intuitionistically | ||
| bi.intuitionistically_alt_fixpoint | ||
| bi.intuitionistically_intro | ||
| bi.limit_preserving_emp_valid | ||
| bi.persistent_absorbingly_affinely | ||
| bi.persistent_and_sep_assoc | ||
| bi.persistent_impl_wand_affinely | ||
| bi.persistent_sep_dup | ||
| bi.persistent_sep_dup_1 | ||
| bi.pure_flip_mono | ||
| bi.pure_impl_forall | ||
| bi.pure_wand_forall | ||
| bi.wandM_sound | ||
| bi.wand_iff_sym | ||
| bi.wand_iff_trans | ||
| bi.Absorbing_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.Affine_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.False_affine | Iris.BI.false_affine | |
| bi.False_and | Iris.BI.false_and | |
| bi.False_elim | Iris.BI.false_elim | |
| bi.False_impl | Iris.BI.false_imp | |
| bi.False_or | Iris.BI.false_or | |
| bi.False_sep | Iris.BI.instLeftAbsorbBiEntailsPureFalseSep | |
| bi.False_wand | Iris.BI.false_wand | |
| bi.Persistent_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.True_affine_all_affine | Iris.BI.True_affine_all_affine | |
| bi.True_and | Iris.BI.true_and | |
| bi.True_emp | Iris.BI.true_emp | |
| bi.True_emp_iff_BiAffine | Iris.BI.biaffine_iff_true_emp | |
| bi.True_impl | Iris.BI.true_imp | |
| bi.True_intro | Iris.BI.true_intro | |
| bi.True_or | Iris.BI.true_or | |
| bi.True_sep | Iris.BI.true_sep | |
| bi.True_sep' | Iris.BI.true_sep_flip | |
| bi.True_sep_2 | Iris.BI.true_sep_mpr | |
| bi.absorbing_absorbingly | Iris.BI.absorbing_absorbingly | |
| bi.absorbingly_True | Iris.BI.absorbingly_true | |
| bi.absorbingly_absorbing | Iris.BI.absorbingly_absorbing | |
| bi.absorbingly_and_1 | Iris.BI.absorbingly_and | |
| bi.absorbingly_elim_persistently | Iris.BI.absorbingly_persistently | |
| bi.absorbingly_emp_True | Iris.BI.absorbingly_emp | |
| bi.absorbingly_exist | Iris.BI.absorbingly_exists | |
| bi.absorbingly_flip_mono' | Use _mono. | |
| bi.absorbingly_forall | Iris.BI.absorbingly_forall | |
| bi.absorbingly_idemp | Iris.BI.absorbingly_idem | |
| bi.absorbingly_if_absorbingly | Iris.BI.absorbingly_if_absorbingly | |
| bi.absorbingly_if_and_1 | Iris.BI.absorbinglyIf_and | |
| bi.absorbingly_if_exist | Iris.BI.absorbinglyIf_exists | |
| bi.absorbingly_if_flag_mono | Iris.BI.absorbinglyIf_flag_mono | |
| bi.absorbingly_if_flip_mono' | Use _mono. | |
| bi.absorbingly_if_forall | Iris.BI.absorbinglyIf_forall | |
| bi.absorbingly_if_idemp | Iris.BI.absorbingly_if_idem | |
| bi.absorbingly_if_intro | Iris.BI.absorbinglyIf_intro | |
| bi.absorbingly_if_mono | Iris.BI.absorbinglyIf_mono | |
| bi.absorbingly_if_mono' | Use _mono. | |
| bi.absorbingly_if_ne | Iris.BI.absorbinglyIf_ne | |
| bi.absorbingly_if_or | Iris.BI.absorbinglyIf_or | |
| bi.absorbingly_if_persistent | Iris.BI.absorbinglyIf_persistent | |
| bi.absorbingly_if_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.absorbingly_if_pure | Iris.BI.absorbinglyIf_pure | |
| bi.absorbingly_if_sep | Iris.BI.absorbinglyIf_sep | |
| bi.absorbingly_if_sep_l | Iris.BI.absorbinglyIf_sep_left | |
| bi.absorbingly_if_sep_lr | Iris.BI.absorbinglyIf_sep_left_right | |
| bi.absorbingly_if_sep_r | Iris.BI.absorbinglyIf_sep_right | |
| bi.absorbingly_if_wand | Iris.BI.absorbinglyIf_wand | |
| bi.absorbingly_intro | Iris.BI.absorbingly_intro | |
| bi.absorbingly_intuitionistically_into_persistently | Iris.BI.absorbingly_intuitionistically | |
| bi.absorbingly_mono | Iris.BI.absorbingly_mono | |
| bi.absorbingly_mono' | Use _mono. | |
| bi.absorbingly_ne | Iris.BI.absorbingly_ne | |
| bi.absorbingly_or | Iris.BI.absorbingly_or | |
| bi.absorbingly_persistent | Iris.BI.absorbingly_persistent | |
| bi.absorbingly_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.absorbingly_pure | Iris.BI.absorbingly_pure | |
| bi.absorbingly_sep | Iris.BI.absorbingly_sep | |
| bi.absorbingly_sep_l | Iris.BI.absorbingly_sep_left | |
| bi.absorbingly_sep_lr | Iris.BI.absorbingly_sep_left_right | |
| bi.absorbingly_sep_r | Iris.BI.absorbingly_sep_right | |
| bi.absorbingly_wand | Iris.BI.absorbingly_wand | |
| bi.affine_affinely | Iris.BI.affine_affinely | |
| bi.affinely_False | Iris.BI.affinely_false | |
| bi.affinely_True_emp | Iris.BI.affinely_true | |
| bi.affinely_absorbingly_elim | Iris.BI.affinely_absorbingly_elim | |
| bi.affinely_affine | Iris.BI.affinely_affine | |
| bi.affinely_affinely_if | Iris.BI.affinely_affinelyIf | |
| bi.affinely_and | Iris.BI.affinely_and | |
| bi.affinely_and_l | Iris.BI.affinely_and_left | |
| bi.affinely_and_lr | Iris.BI.affinely_and_left_right | |
| bi.affinely_and_r | Iris.BI.affinely_and_right | |
| bi.affinely_elim | Iris.BI.affinely_elim | |
| bi.affinely_elim_emp | Iris.BI.affinely_elim_emp | |
| bi.affinely_emp | Iris.BI.affinely_emp | |
| bi.affinely_exist | Iris.BI.affinely_exists | |
| bi.affinely_flip_mono' | Use _mono. | |
| bi.affinely_forall | Iris.BI.affinely_forall | |
| bi.affinely_idemp | Iris.BI.affinely_idem | |
| bi.affinely_if_absorbingly_if_elim | Iris.BI.affinely_if_absorbingly_if_elim | |
| bi.affinely_if_affine | Iris.BI.affinelyIf_affine | |
| bi.affinely_if_and | Iris.BI.affinelyIf_and | |
| bi.affinely_if_and_l | Iris.BI.affinelyIf_and_left | |
| bi.affinely_if_and_lr | Iris.BI.affinelyIf_and_left_right | |
| bi.affinely_if_and_r | Iris.BI.affinelyIf_and_right | |
| bi.affinely_if_elim | Iris.BI.affinelyIf_elim | |
| bi.affinely_if_emp | Iris.BI.affinelyIf_emp | |
| bi.affinely_if_exist | Iris.BI.affinelyIf_exists | |
| bi.affinely_if_flag_mono | Iris.BI.affinelyIf_flag_mono | |
| bi.affinely_if_flip_mono' | Use _mono. | |
| bi.affinely_if_idemp | Iris.BI.affinely_if_idem | |
| bi.affinely_if_intro' | Iris.BI.affinelyIf_intro_affinelyIf | |
| bi.affinely_if_mono | Iris.BI.affinelyIf_mono | |
| bi.affinely_if_mono' | Use _mono. | |
| bi.affinely_if_ne | Iris.BI.affinelyIf_ne | |
| bi.affinely_if_or | Iris.BI.affinelyIf_or | |
| bi.affinely_if_persistent | Iris.BI.affinelyIf_persistent | |
| bi.affinely_if_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.affinely_if_sep | Iris.BI.affinelyIf_sep | |
| bi.affinely_if_sep_2 | Iris.BI.affinelyIf_sep_mpr | |
| bi.affinely_intro | Iris.BI.affinely_intro | |
| bi.affinely_intro' | Iris.BI.affinely_intro_of_affinely | |
| bi.affinely_mono | Iris.BI.affinely_mono | |
| bi.affinely_mono' | Use _mono. | |
| bi.affinely_ne | Iris.BI.affinely_ne | |
| bi.affinely_or | Iris.BI.affinely_or | |
| bi.affinely_persistent | Iris.BI.affinely_persistent | |
| bi.affinely_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.affinely_sep | Iris.BI.affinely_sep | |
| bi.affinely_sep_2 | Iris.BI.affinely_sep_mpr | |
| bi.and_False | Iris.BI.and_false | |
| bi.and_True | Iris.BI.and_true | |
| bi.and_absorbing | Iris.BI.and_absorbing | |
| bi.and_affine_l | Iris.BI.and_affine_left | |
| bi.and_affine_r | Iris.BI.and_affine_right | |
| bi.and_alt | Iris.BI.and_forall_ite | |
| bi.and_assoc | Iris.BI.and_assoc | |
| bi.and_comm | Iris.BI.and_comm | |
| bi.and_elim_l' | Iris.BI.and_elim_left_trans | |
| bi.and_elim_r' | Iris.BI.and_elim_right_trans | |
| bi.and_emp | Iris.BI.and_emp | |
| bi.and_emp' | Iris.BI.and_emp_biaffine | |
| bi.and_exist_l | Iris.BI.and_exists_left | |
| bi.and_exist_r | Iris.BI.and_exists_right | |
| bi.and_flip_mono' | Use and_mono | |
| bi.and_idem | Iris.BI.instIdempotentBiEntailsAnd | |
| bi.and_mono | Iris.BI.and_mono | |
| bi.and_mono' | Use and_mono | |
| bi.and_mono_l | Iris.BI.and_mono_left | |
| bi.and_mono_r | Iris.BI.and_mono_right | |
| bi.and_or_l | Iris.BI.and_or_left | |
| bi.and_or_r | Iris.BI.and_or_right | |
| bi.and_persistent | Iris.BI.and_persistent | |
| bi.and_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.and_sep_intuitionistically | Iris.BI.and_sep_intuitionistically | |
| bi.and_sep_persistently | Iris.BI.persistently_and_persistently_sep | |
| bi.bi_affine_absorbing | Iris.BI.bi_affine_absorbing | |
| bi.bi_affine_positive | Iris.BI.bi_affine_positive | |
| bi.bi_and_monoid | Iris.BI.bi_and_monoid | |
| bi.bi_emp_valid_flip_mono | Iris.BI.bi_emp_valid_flip_mono | |
| bi.bi_emp_valid_mono | Iris.BI.bi_emp_valid_mono | |
| bi.bi_emp_valid_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.bi_persistently_and_homomorphism | Iris.BI.bi_persistently_and_homomorphism | |
| bi.bi_persistently_or_homomorphism | Iris.BI.bi_persistently_or_homomorphism | |
| bi.bi_persistently_sep_entails_homomorphism | Iris.BI.bi_persistently_sep_entails_homomorphism | |
| bi.bi_persistently_sep_entails_weak_homomorphism | Iris.BI.bi_persistently_sep_entails_weak_homomorphism | |
| bi.bi_persistently_sep_homomorphism | Iris.BI.bi_persistently_sep_homomorphism | |
| bi.bi_persistently_sep_weak_homomorphism | Iris.BI.bi_persistently_sep_weak_homomorphism | |
| bi.bi_pure_forall_em | Do not need BiPureForall in Lean | |
| bi.bi_sep_monoid | Iris.BI.bi_sep_monoid | |
| bi.emp_absorbing_all_absorbing | Iris.BI.absorbing_of_emp_absorbing | |
| bi.emp_affine | Iris.BI.emp_affine | |
| bi.emp_and | Iris.BI.emp_and | |
| bi.emp_and' | Iris.BI.emp_and_biaffine | |
| bi.emp_or | Iris.BI.emp_or | |
| bi.emp_persistent | Iris.BI.emp_persistent | |
| bi.emp_sep | Iris.BI.instLeftIdBiEntailsEmpSep | |
| bi.emp_wand | Iris.BI.emp_wand | |
| bi.entails_eq_True | Iris.BI.entails_eq_true | |
| bi.entails_equiv_and | Iris.BI.entails_equiv_and | |
| bi.entails_equiv_l | Iris.BI.entails_equiv_left | |
| bi.entails_equiv_r | Iris.BI.entails_equiv_right | |
| bi.entails_impl_True | Iris.BI.entails_impl_true | |
| bi.entails_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.entails_wand | Iris.BI.entails_wand | |
| bi.entails_wand' | Iris.BI.entails_wand_emp | |
| bi.equiv_entails_1_1 | Use `BiEntails.mp`. | |
| bi.equiv_entails_1_2 | Use `BiEntails.mpr`. | |
| bi.equiv_wand_iff | Iris.BI.equiv_wandIff | |
| bi.exist_absorbing | Iris.BI.exists_absorbing | |
| bi.exist_affine | Iris.BI.exists_affine | |
| bi.exist_exist | Iris.BI.exists_exists | |
| bi.exist_flip_mono' | Use exists_mono | |
| bi.exist_forall | Iris.BI.exists_forall | |
| bi.exist_impl_forall | Iris.BI.exists_impl_forall | |
| bi.exist_intro' | Iris.BI.exists_intro_trans | |
| bi.exist_mono | Iris.BI.exists_mono | |
| bi.exist_mono' | Use exists_mono | |
| bi.exist_persistent | Iris.BI.exists_persistent | |
| bi.exist_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.exist_unit | Iris.BI.exists_unit | |
| bi.forall_absorbing | Iris.BI.forall_absorbing | |
| bi.forall_affine | Iris.BI.forall_affine | |
| bi.forall_elim' | Iris.BI.forall_elim_trans | |
| bi.forall_flip_mono' | Use forall_mono | |
| bi.forall_forall | Iris.BI.forall_forall | |
| bi.forall_mono | Iris.BI.forall_mono | |
| bi.forall_mono' | Use forall_mono | |
| bi.forall_persistent | Iris.BI.forall_persistent | |
| bi.forall_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.forall_unit | Iris.BI.forall_unit | |
| bi.iff_ne | Iris.BI.iff_ne | |
| bi.iff_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.iff_refl | Iris.BI.iff_refl_alias | |
| bi.impl_absorbing | Iris.BI.imp_absorbing | |
| bi.impl_curry | Iris.BI.impl_curry | |
| bi.impl_elim | Iris.BI.imp_mp | |
| bi.impl_elim_l | Iris.BI.imp_elim_left | |
| bi.impl_elim_r | Iris.BI.imp_elim_right | |
| bi.impl_elim_r' | Iris.BI.imp_elim_swap | |
| bi.impl_flip_mono' | Use imp_mono | |
| bi.impl_intro_l | Iris.BI.imp_intro_swap | |
| bi.impl_mono | Iris.BI.imp_mono | |
| bi.impl_mono' | Use imp_mono | |
| bi.impl_proper | Derivable from _ne with NonExpansive.eqv | |
| bi.impl_refl | Iris.BI.imp_self | |
| bi.impl_trans | Iris.BI.imp_trans | |
| bi.impl_wand_1 | Iris.BI.imp_wand | |
| bi.impl_wand_persistently | Iris.BI.imp_wand_persistently | |
| bi.impl_wand_persistently_2 | Iris.BI.imp_wand_persistently_mpr | |
| bi.intuitionistic | Iris.BI.intuitionistic_alias | |
| bi.intuitionistic_intuitionistically | Iris.BI.intuitionistic_intuitionistically_alias | |
| bi.intuitionistically_False | Iris.BI.intuitionistically_false | |
| bi.intuitionistically_True_emp | Iris.BI.intuitionistically_true | |
| bi.intuitionistically_affine | Iris.BI.intuitionistically_affine | |
| bi.intuitionistically_affinely | Iris.BI.intuitionistically_affinely | |
| bi.intuitionistically_affinely_elim | Iris.BI.intuitionistically_affinely | |
| bi.intuitionistically_and | Iris.BI.intuitionistically_and | |
| bi.intuitionistically_def | Iris.BI.intuitionistically_def | |
| bi.intuitionistically_elim | Iris.BI.intuitionistically_elim | |
| bi.intuitionistically_elim_emp | Iris.BI.intuitionistically_elim_emp | |
| bi.intuitionistically_emp | Iris.BI.intuitionistically_emp | |
| bi.intuitionistically_exist | Iris.BI.intuitionistically_exists | |
| bi.intuitionistically_flip_mono' | Use _mono. | |
| bi.intuitionistically_forall | Iris.BI.intuitionistically_forall | |
| bi.intuitionistically_idemp | Iris.BI.intuitionistically_idem | |
| bi.intuitionistically_if_False | Iris.BI.intuitionisticallyIf_false | |
| bi.intuitionistically_if_affine | Iris.BI.intuitionisticallyIf_affine | |
| bi.intuitionistically_if_and | Iris.BI.intuitionisticallyIf_and | |
| bi.intuitionistically_if_elim | Iris.BI.intuitionisticallyIf_elim | |
| bi.intuitionistically_if_emp | Iris.BI.intuitionisticallyIf_emp | |
| bi.intuitionistically_if_exist | Iris.BI.intuitionistically_if_exists | |
| bi.intuitionistically_if_flag_mono | Iris.BI.intuitionisticallyIf_flag_mono | |
| bi.intuitionistically_if_flip_mono' | Use _mono. | |
| bi.intuitionistically_if_idemp | Iris.BI.intuitionistically_if_idem | |
| bi.intuitionistically_if_intro' | Iris.BI.intuitionisticallyIf_intro_intuitionisticallyIf | |
| bi.intuitionistically_if_mono | Iris.BI.intuitionisticallyIf_mono | |
| bi.intuitionistically_if_mono' | Use _mono. | |
| bi.intuitionistically_if_ne | Iris.BI.intuitionisticallyIf_ne | |
| bi.intuitionistically_if_or | Iris.BI.intuitionisticallyIf_or | |
| bi.intuitionistically_if_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.intuitionistically_if_sep | Iris.BI.intuitionisticallyIf_sep | |
| bi.intuitionistically_if_sep_2 | Iris.BI.intuitionisticallyIf_sep_mpr | |
| bi.intuitionistically_if_unfold | Iris.BI.intuitionistically_if_unfold | |
| bi.intuitionistically_impl_wand_2 | Iris.BI.intuitionistically_imp_wand | |
| bi.intuitionistically_into_persistently | Iris.BI.intuitionistically_into_persistently | |
| bi.intuitionistically_into_persistently_1 | Iris.BI.persistently_of_intuitionistically | |
| bi.intuitionistically_intro' | Iris.BI.intuitionistically_intro_intuitionistically | |
| bi.intuitionistically_intuitionistically_if | Iris.BI.intuitionisticallyIf_of_intuitionistically | |
| bi.intuitionistically_mono' | Use _mono. | |
| bi.intuitionistically_ne | Iris.BI.intuitionistically_ne | |
| bi.intuitionistically_or | Iris.BI.intuitionistically_or | |
| bi.intuitionistically_persistent | Iris.BI.intuitionistically_persistent | |
| bi.intuitionistically_persistently_elim | Iris.BI.intuitionistically_persistently | |
| bi.intuitionistically_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.intuitionistically_sep | Iris.BI.intuitionistically_sep | |
| bi.intuitionistically_sep_2 | Iris.BI.intuitionistically_sep_mpr | |
| bi.intuitionistically_sep_dup | Iris.BI.intuitionistically_sep_idem | |
| bi.iter_modal_intro | Iris.BI.iter_modal_intro | |
| bi.iter_modal_mono | Iris.BI.iter_modal_mono | |
| bi.limit_preserving_Persistent | Iris.BI.limitPreserving_persistent | |
| bi.limit_preserving_entails | Iris.BI.LimitPreserving.entails | |
| bi.or_False | Iris.BI.or_false | |
| bi.or_True | Iris.BI.or_true | |
| bi.or_absorbing | Iris.BI.or_absorbing | |
| bi.or_affine | Iris.BI.or_affine | |
| bi.or_alt | Iris.BI.or_exists_ite | |
| bi.or_and_l | Iris.BI.or_and_left | |
| bi.or_and_r | Iris.BI.or_and_right | |
| bi.or_assoc | Iris.BI.or_assoc | |
| bi.or_comm | Iris.BI.or_comm | |
| bi.or_emp | Iris.BI.or_emp | |
| bi.or_exist | Iris.BI.or_exists | |
| bi.or_flip_mono' | Use or_mono | |
| bi.or_idem | Iris.BI.instIdempotentBiEntailsOr | |
| bi.or_intro_l' | Iris.BI.or_intro_left_trans | |
| bi.or_intro_r' | Iris.BI.or_intro_right_trans | |
| bi.or_mono | Iris.BI.or_mono | |
| bi.or_mono' | Use or_mono | |
| bi.or_mono_l | Iris.BI.or_mono_left | |
| bi.or_mono_r | Iris.BI.or_mono_right | |
| bi.or_persistent | Iris.BI.or_persistent | |
| bi.or_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.persistent_absorbingly_affinely_2 | Iris.BI.absorbingly_affinely_intro_of_persistent | |
| bi.persistent_and_affinely_sep_l | Iris.BI.persistent_and_affinely_sep_left | |
| bi.persistent_and_affinely_sep_l_1 | Iris.BI.persistent_and_affinely_sep_left_mp | |
| bi.persistent_and_affinely_sep_r | Iris.BI.persistent_and_affinely_sep_right | |
| bi.persistent_and_affinely_sep_r_1 | Iris.BI.persistent_and_affinely_sep_right_mp | |
| bi.persistent_and_sep | Iris.BI.persistent_and_sep | |
| bi.persistent_and_sep_1 | Iris.BI.persistent_and_sep_mp | |
| bi.persistent_entails_l | Iris.BI.persistent_entails_right | |
| bi.persistent_entails_r | Iris.BI.persistent_entails_left | |
| bi.persistent_persistently | Iris.BI.persistently_iff | |
| bi.persistent_persistently_2 | Use `Persistent.persistent`. | |
| bi.persistently_True | Iris.BI.persistently_true | |
| bi.persistently_True_emp | Iris.BI.persistently_True_emp | |
| bi.persistently_affinely_elim | Iris.BI.persistently_affinely | |
| bi.persistently_alt_fixpoint | Iris.BI.self_sep_persistently | |
| bi.persistently_alt_fixpoint' | Iris.BI.affinely_sep_persistently | |
| bi.persistently_and | Iris.BI.persistently_and | |
| bi.persistently_and_emp | Iris.BI.persistently_and_emp | |
| bi.persistently_and_emp_elim | Iris.BI.persistently_and_emp_elim | |
| bi.persistently_and_intuitionistically_sep_l | Iris.BI.persistently_and_intuitionistically_sep_left | |
| bi.persistently_and_intuitionistically_sep_r | Iris.BI.persistently_and_intuitionistically_sep_right | |
| bi.persistently_and_sep | Iris.BI.persistently_and_sep | |
| bi.persistently_and_sep_assoc | Iris.BI.persistently_and_sep_assoc | |
| bi.persistently_and_sep_elim_emp | Iris.BI.persistently_and_sep_elim_emp | |
| bi.persistently_and_sep_l | Iris.BI.persistently_and_iff_sep | |
| bi.persistently_and_sep_l_1 | Iris.BI.persistently_and_imp_sep | |
| bi.persistently_and_sep_r | Iris.BI.and_persistently_iff_sep | |
| bi.persistently_and_sep_r_1 | Iris.BI.and_persistently_imp_sep | |
| bi.persistently_elim | Iris.BI.persistently_elim | |
| bi.persistently_emp | Iris.BI.persistently_emp | |
| bi.persistently_emp_intro | Iris.BI.persistently_emp_intro | |
| bi.persistently_entails_l | Iris.BI.persistently_entails_left | |
| bi.persistently_entails_r | Iris.BI.persistently_entails_right | |
| bi.persistently_exist | Iris.BI.persistently_exists | |
| bi.persistently_flip_mono' | Use _mono. | |
| bi.persistently_forall | Iris.BI.persistently_forall | |
| bi.persistently_forall_1 | Iris.BI.persistently_forall_mp | |
| bi.persistently_idemp | Iris.BI.persistently_idem | |
| bi.persistently_idemp_1 | Use `persistently_idem.mp`. | |
| bi.persistently_if_absorbing | Iris.BI.persistentlyIf_absorbing | |
| bi.persistently_if_and | Iris.BI.persistentlyIf_and | |
| bi.persistently_if_exist | Iris.BI.persistentlyIf_exists | |
| bi.persistently_if_flip_mono' | Use _mono. | |
| bi.persistently_if_idemp | Iris.BI.persistently_if_idem | |
| bi.persistently_if_mono | Iris.BI.persistentlyIf_mono | |
| bi.persistently_if_mono' | Use _mono. | |
| bi.persistently_if_ne | Iris.BI.persistentlyIf_ne | |
| bi.persistently_if_or | Iris.BI.persistentlyIf_or | |
| bi.persistently_if_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.persistently_if_pure | Iris.BI.persistentlyIf_pure | |
| bi.persistently_if_sep | Iris.BI.persistentlyIf_sep | |
| bi.persistently_if_sep_2 | Iris.BI.persistentlyIf_sep_mpr | |
| bi.persistently_impl | Iris.BI.persistently_imp | |
| bi.persistently_impl_wand | Iris.BI.persistently_imp_wand | |
| bi.persistently_impl_wand_2 | Iris.BI.persistently_imp_wand_mpr | |
| bi.persistently_into_absorbingly | Iris.BI.absorbingly_of_persistently | |
| bi.persistently_intro | Iris.BI.persistently_intro_of_persistent | |
| bi.persistently_intro' | Iris.BI.persistently_intro_persistently | |
| bi.persistently_mono' | Use _mono. | |
| bi.persistently_or | Iris.BI.persistently_or | |
| bi.persistently_persistent | Iris.BI.persistently_persistent | |
| bi.persistently_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.persistently_pure | Iris.BI.persistently_pure | |
| bi.persistently_sep | Iris.BI.persistently_sep | |
| bi.persistently_sep_2 | Iris.BI.persistently_sep_mpr | |
| bi.persistently_sep_dup | Iris.BI.persistently_sep_persistently | |
| bi.persistently_wand | Iris.BI.persistently_wand | |
| bi.pure_False | Iris.BI.pure_false | |
| bi.pure_True | Iris.BI.pure_true | |
| bi.pure_absorbing | Iris.BI.pure_absorbing | |
| bi.pure_alt | Iris.BI.pure_alt | |
| bi.pure_and | Iris.BI.pure_and | |
| bi.pure_elim | Iris.BI.pure_elim | |
| bi.pure_elim_l | Iris.BI.pure_elim_left | |
| bi.pure_elim_r | Iris.BI.pure_elim_right | |
| bi.pure_exist | Iris.BI.pure_exists | |
| bi.pure_forall | Iris.BI.pure_forall | |
| bi.pure_forall_1 | Proven as pure_forall.1 | |
| bi.pure_iff | Iris.BI.pure_iff | |
| bi.pure_impl | Iris.BI.pure_imp | |
| bi.pure_impl_1 | Proven as pure_imp.1 | |
| bi.pure_impl_2 | Proven as pure_imp.2 | |
| bi.pure_mono | Iris.BI.pure_mono | |
| bi.pure_mono' | Use _mono. | |
| bi.pure_or | Iris.BI.pure_or | |
| bi.pure_persistent | Iris.BI.pure_persistent | |
| bi.pure_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.sep_False | Iris.BI.instRightAbsorbBiEntailsPureFalseSep | |
| bi.sep_True | Iris.BI.sep_true | |
| bi.sep_True' | Iris.BI.sep_true_flip | |
| bi.sep_True_2 | Iris.BI.sep_true_mpr | |
| bi.sep_absorbing_l | Iris.BI.sep_absorbing_left | |
| bi.sep_absorbing_r | Iris.BI.sep_absorbing_right | |
| bi.sep_affine | Iris.BI.sep_affine | |
| bi.sep_and | Iris.BI.sep_and | |
| bi.sep_and_l | Iris.BI.sep_and_left | |
| bi.sep_and_r | Iris.BI.sep_and_right | |
| bi.sep_assoc | Iris.BI.sep_assoc | |
| bi.sep_comm | Iris.BI.sep_comm | |
| bi.sep_elim_emp_valid_l | Iris.BI.sep_elim_emp_valid_left | |
| bi.sep_elim_emp_valid_r | Iris.BI.sep_elim_emp_valid_right | |
| bi.sep_elim_l | Iris.BI.sep_elim_left | |
| bi.sep_elim_r | Iris.BI.sep_elim_right | |
| bi.sep_emp | Iris.BI.instRightIdBiEntailsEmpSep | |
| bi.sep_exist_l | Iris.BI.sep_exists_left | |
| bi.sep_exist_r | Iris.BI.sep_exists_right | |
| bi.sep_flip_mono' | Use _mono. | |
| bi.sep_forall_l | Iris.BI.sep_forall_left | |
| bi.sep_forall_r | Iris.BI.sep_forall_right | |
| bi.sep_intro_emp_valid_l | Iris.BI.sep_intro_emp_valid_left | |
| bi.sep_intro_emp_valid_r | Iris.BI.sep_intro_emp_valid_right | |
| bi.sep_mono' | Use _mono. | |
| bi.sep_mono_l | Iris.BI.sep_mono_left | |
| bi.sep_mono_r | Iris.BI.sep_mono_right | |
| bi.sep_or_l | Iris.BI.sep_or_left | |
| bi.sep_or_r | Iris.BI.sep_or_right | |
| bi.sep_persistent | Iris.BI.sep_persistent | |
| bi.sep_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.wand_absorbing_l | Iris.BI.wand_absorbing_left | |
| bi.wand_absorbing_r | Iris.BI.wand_absorbing_right | |
| bi.wand_alt | Iris.BI.wand_iff_exists_persistently | |
| bi.wand_apply | Iris.BI.wand_apply | |
| bi.wand_curry | Iris.BI.wand_curry | |
| bi.wand_elim_l | Iris.BI.wand_elim_left | |
| bi.wand_elim_r | Iris.BI.wand_elim_right | |
| bi.wand_elim_r' | Iris.BI.wand_elim_left_trans | |
| bi.wand_entails | Iris.BI.wand_entails | |
| bi.wand_entails' | Iris.BI.wand_entails_emp | |
| bi.wand_flip_mono' | Use _mono. | |
| bi.wand_frame_l | Iris.BI.wand_frame_left | |
| bi.wand_frame_r | Iris.BI.wand_frame_right | |
| bi.wand_iff_equiv | Iris.BI.wandIff_equiv | |
| bi.wand_iff_ne | Iris.BI.wandIff_ne | |
| bi.wand_iff_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.wand_iff_refl | Iris.BI.wandIff_refl | |
| bi.wand_intro_l | Iris.BI.wand_intro_left | |
| bi.wand_mono | Iris.BI.wand_mono | |
| bi.wand_mono' | Use _mono. | |
| bi.wand_proper | Derivable from _ne with NonExpansive.eqv. | |
| bi.wand_refl | Iris.BI.wand_rfl | |
| bi.wand_trans | Iris.BI.wand_trans |
| Rocq Name | Status | Details |
|---|---|---|
| bi.laterN_iter | ||
| bi.löb_alt_wand | ||
| bi.not_not_later_False | ||
| bi.Timeless_proper | Derivable from the BI structure; Timeless is preserved under ⊣⊢. | |
| bi.absorbingly_timeless | Iris.BI.absorbingly_timeless | |
| bi.affinely_timeless | Iris.BI.affinely_timeless | |
| bi.and_timeless | Iris.BI.and_timeless | |
| bi.bi_except_0_and_homomorphism | Iris.BI.bi_except0_and_homomorphism | |
| bi.bi_except_0_or_homomorphism | Iris.BI.bi_except0_or_homomorphism | |
| bi.bi_except_0_sep_entails_homomorphism | Iris.BI.bi_except0_sep_entails_homomorphism | |
| bi.bi_except_0_sep_entails_weak_homomorphism | Iris.BI.bi_except0_sep_entails_weak_homomorphism | |
| bi.bi_except_0_sep_homomorphism | Iris.BI.bi_except0_sep_homomorphism | |
| bi.bi_except_0_sep_weak_homomorphism | Iris.BI.bi_except0_sep_weak_homomorphism | |
| bi.bi_laterN_and_homomorphism | Iris.BI.bi_laterN_and_homomorphism | |
| bi.bi_laterN_or_homomorphism | Iris.BI.bi_laterN_or_homomorphism | |
| bi.bi_laterN_sep_entails_homomorphism | Iris.BI.bi_laterN_sep_entails_homomorphism | |
| bi.bi_laterN_sep_entails_weak_homomorphism | Iris.BI.bi_laterN_sep_entails_weak_homomorphism | |
| bi.bi_laterN_sep_homomorphism | Iris.BI.bi_laterN_sep_homomorphism | |
| bi.bi_laterN_sep_weak_homomorphism | Iris.BI.bi_laterN_sep_weak_homomorphism | |
| bi.bi_later_monoid_and_homomorphism | Iris.BI.bi_later_monoid_and_homomorphism | |
| bi.bi_later_monoid_or_homomorphism | Iris.BI.bi_later_monoid_or_homomorphism | |
| bi.bi_later_monoid_sep_entails_homomorphism | Iris.BI.bi_later_monoid_sep_entails_homomorphism | |
| bi.bi_later_monoid_sep_entails_weak_homomorphism | Iris.BI.bi_later_monoid_sep_entails_weak_homomorphism | |
| bi.bi_later_monoid_sep_homomorphism | Iris.BI.bi_later_monoid_sep_homomorphism | |
| bi.bi_later_monoid_sep_weak_homomorphism | Iris.BI.bi_later_monoid_sep_weak_homomorphism | |
| bi.emp_timeless | Iris.BI.emp_timeless | |
| bi.except_0_True | Iris.BI.except0_true | |
| bi.except_0_absorbing | Iris.BI.except0_absorbing | |
| bi.except_0_absorbingly | Iris.BI.except0_absorbingly | |
| bi.except_0_affinely_2 | Iris.BI.except0_affinely | |
| bi.except_0_and | Iris.BI.except0_and | |
| bi.except_0_emp | Iris.BI.except0_emp | |
| bi.except_0_exist | Iris.BI.except0_exists | |
| bi.except_0_exist_2 | Iris.BI.except0_exists_mpr | |
| bi.except_0_flip_mono' | Use except0_mono | |
| bi.except_0_forall | Iris.BI.except0_forall | |
| bi.except_0_frame_l | Iris.BI.except0_frame_left | |
| bi.except_0_frame_r | Iris.BI.except0_frame_right | |
| bi.except_0_idemp | Iris.BI.except0_idem | |
| bi.except_0_into_later | Iris.BI.except0_into_later | |
| bi.except_0_intro | Iris.BI.except0_intro | |
| bi.except_0_intuitionistically_2 | Iris.BI.except0_intuitionistically | |
| bi.except_0_intuitionistically_if_2 | Iris.BI.except0_intuitionisticallyIf | |
| bi.except_0_later | Iris.BI.except0_later | |
| bi.except_0_laterN | Iris.BI.except0_laterN | |
| bi.except_0_mono | Iris.BI.except0_mono | |
| bi.except_0_mono' | Use except0_mono. | |
| bi.except_0_ne | Iris.BI.except0_ne | |
| bi.except_0_or | Iris.BI.except0_or | |
| bi.except_0_persistent | Iris.BI.except0_persistent | |
| bi.except_0_persistently | Iris.BI.except0_persistently | |
| bi.except_0_proper | Derivable from except0_ne with NonExpansive.eqv | |
| bi.except_0_sep | Iris.BI.except0_sep | |
| bi.exist_timeless | Iris.BI.exists_timeless | |
| bi.forall_timeless | Iris.BI.forall_timeless | |
| bi.from_option_timeless | Iris.BI.from_option_timeless | |
| bi.impl_timeless | Iris.BI.impl_timeless | |
| bi.intuitionistically_timeless | Iris.BI.intuitionistically_timeless | |
| bi.laterN_0 | Iris.BI.laterN_0 | |
| bi.laterN_True | Iris.BI.laterN_true | |
| bi.laterN_absorbing | Iris.BI.laterN_absorbing | |
| bi.laterN_absorbingly | Iris.BI.laterN_absorbingly | |
| bi.laterN_add | Iris.BI.laterN_add | |
| bi.laterN_affinely_2 | Iris.BI.laterN_affinely | |
| bi.laterN_and | Iris.BI.laterN_and | |
| bi.laterN_emp | Iris.BI.laterN_emp | |
| bi.laterN_exist | Iris.BI.laterN_exists | |
| bi.laterN_exist_2 | Iris.BI.laterN_exists_mpr | |
| bi.laterN_flip_mono' | Use laterN_mono. | |
| bi.laterN_forall | Iris.BI.laterN_forall | |
| bi.laterN_iff | Iris.BI.laterN_iff | |
| bi.laterN_impl | Iris.BI.laterN_imp | |
| bi.laterN_intro | Iris.BI.laterN_intro | |
| bi.laterN_intuitionistically_2 | Iris.BI.laterN_intuitionistically | |
| bi.laterN_intuitionistically_if_2 | Iris.BI.laterN_intuitionisticallyIf | |
| bi.laterN_later | Iris.BI.laterN_later | |
| bi.laterN_le | Iris.BI.laterN_le | |
| bi.laterN_mono | Iris.BI.laterN_mono | |
| bi.laterN_mono' | Use laterN_mono. | |
| bi.laterN_ne | Iris.BI.laterN_ne | |
| bi.laterN_or | Iris.BI.laterN_or | |
| bi.laterN_persistent | Iris.BI.laterN_persistent | |
| bi.laterN_persistently | Iris.BI.laterN_persistently | |
| bi.laterN_proper | Derivable from laterN_ne with NonExpansive.eqv | |
| bi.laterN_sep | Iris.BI.laterN_sep | |
| bi.laterN_wand | Iris.BI.laterN_wand | |
| bi.later_True | Iris.BI.later_true | |
| bi.later_absorbing | Iris.BI.later_absorbing | |
| bi.later_absorbingly | Iris.BI.later_absorbingly | |
| bi.later_affinely | Iris.BI.later_affinely | |
| bi.later_affinely_1 | Iris.BI.later_affinely_mp | |
| bi.later_affinely_2 | Iris.BI.later_affinely_mpr | |
| bi.later_and | Iris.BI.later_and | |
| bi.later_contractive_bi_löb | Iris.BI.later_contractive_bi_loeb | |
| bi.later_emp | Iris.BI.later_emp | |
| bi.later_exist | Iris.BI.later_exists | |
| bi.later_exist_2 | Iris.BI.later_exists_mp | |
| bi.later_exist_except_0 | Iris.BI.later_exists_except0 | |
| bi.later_flip_mono' | Use later_mono. | |
| bi.later_forall | Iris.BI.later_forall | |
| bi.later_iff | Iris.BI.later_iff | |
| bi.later_impl | Iris.BI.later_imp | |
| bi.later_intuitionistically | Iris.BI.later_intuitionistically | |
| bi.later_intuitionistically_2 | Iris.BI.later_intuitionistically_2 | |
| bi.later_intuitionistically_if | Iris.BI.later_intuitionisticallyIf | |
| bi.later_intuitionistically_if_2 | Iris.BI.later_intuitionisticallyIf_2 | |
| bi.later_laterN | Iris.BI.later_laterN | |
| bi.later_mono' | Use later_mono. | |
| bi.later_or | Iris.BI.later_or | |
| bi.later_persistent | Iris.BI.later_persistent | |
| bi.later_persistently | Iris.BI.later_persistently_alias | |
| bi.later_proper | Derivable from later_ne with NonExpansive.eqv | |
| bi.later_sep | Iris.BI.later_sep_alias | |
| bi.later_wand | Iris.BI.later_wand | |
| bi.later_wand_iff | Iris.BI.later_wand_iff | |
| bi.löb | Iris.BI.loeb | |
| bi.löb_alt_strong | Iris.BI.loeb_weak_of_strong | |
| bi.löb_wand | Iris.BI.loeb_wand | |
| bi.löb_wand_intuitionistically | Iris.BI.loeb_wand_intuitionistically | |
| bi.or_timeless | Iris.BI.or_timeless | |
| bi.persistently_timeless | Iris.BI.persistently_timeless | |
| bi.pure_timeless | Iris.BI.pure_timeless | |
| bi.sep_timeless | Iris.BI.sep_timeless | |
| bi.timeless_alt | Iris.BI.timeless_alt | |
| bi.timeless_laterN | Iris.BI.timeless_laterN | |
| bi.wand_timeless | Iris.BI.wand_timeless |
| Rocq Name | Status | Details |
|---|---|---|
| BiEmbed | Iris.BI.BiEmbed | |
| BiEmbedBUpd | Iris.BI.BiEmbedBUpd | |
| BiEmbedEmp | Iris.BI.BiEmbedEmp | |
| BiEmbedFUpd | Iris.BI.BiEmbedFUpd | |
| BiEmbedLater | Iris.BI.BiEmbedLater | |
| BiEmbedMixin | Use the BiEmbed type class. | |
| BiEmbedSbi | Iris.BI.BiEmbedSbi | |
| Embed | Iris.BI.Embed | |
| embed_absorbing | Iris.BI.embed_absorbing | |
| embed_absorbingly | Iris.BI.embed_absorbingly | |
| embed_absorbingly_if | Iris.BI.embed_absorbingly_if | |
| embed_affine | Iris.BI.embed_affine | |
| embed_affinely | Iris.BI.embed_affinely | |
| embed_affinely_2 | Iris.BI.embed_affinely_2 | |
| embed_affinely_if | Iris.BI.embed_affinely_if | |
| embed_affinely_if_2 | Iris.BI.embed_affinely_if_2 | |
| embed_and | Iris.BI.embed_and | |
| embed_and_homomorphism | Iris.BI.embed_and_homomorphism | |
| embed_bi_embed | Iris.BI.embedBiEmbed | |
| embed_big_sepL | Iris.BI.embed_big_sepL | |
| embed_big_sepL_2 | Iris.BI.embed_big_sepL_2 | |
| embed_big_sepM | Iris.BI.embed_big_sepM | |
| embed_big_sepMS | gmultiset big-ops are not yet ported in iris-lean (no BigSepMSet). | |
| embed_big_sepMS_2 | gmultiset big-ops are not yet ported in iris-lean (no BigSepMSet). | |
| embed_big_sepM_2 | Iris.BI.embed_big_sepM_2 | |
| embed_big_sepS | Iris.BI.embed_big_sepS | |
| embed_big_sepS_2 | Iris.BI.embed_big_sepS_2 | |
| embed_embed | Iris.BI.embedEmbed | |
| embed_embed_alt | Iris.BI.embed_embed_alt | |
| embed_embed_bupd | Iris.BI.embed_embed_bupd | |
| embed_embed_emp | Iris.BI.embed_embed_emp | |
| embed_embed_fupd | Iris.BI.embed_embed_fupd | |
| embed_embed_later | Iris.BI.embed_embed_later | |
| embed_embed_sbi | Iris.BI.embed_embed_sbi | |
| embed_embedding_mixin | Subsumed by embedBiEmbed. | |
| embed_emp | Iris.BI.embed_emp | |
| embed_emp_2 | Iris.BI.embed_emp_2 | |
| embed_emp_valid | Iris.BI.embed_emp_valid | |
| embed_emp_valid_inj | Iris.BI.embed_emp_valid_inj | |
| embed_entails_inj | Iris.BI.embed_entails_inj | |
| embed_except_0 | Iris.BI.embed_except_0 | |
| embed_exist | Iris.BI.embed_exist | |
| embed_exist_1 | Iris.BI.embed_sExists_1 | |
| embed_flip_mono | iris-lean has no setoid `Proper` instances; covered by `embed_mono`. | |
| embed_forall | Iris.BI.embed_forall | |
| embed_forall_2 | Iris.BI.embed_sForall_2 | |
| embed_iff | Iris.BI.embed_iff | |
| embed_impl | Iris.BI.embed_impl | |
| embed_impl_2 | Iris.BI.embed_impl_2 | |
| embed_inj | Iris.BI.embed_inj | |
| embed_internal_eq | Iris.BI.embed_internal_eq | |
| embed_internal_inj | Iris.BI.embed_internal_inj | |
| embed_intuitionistically | Iris.BI.embed_intuitionistically | |
| embed_intuitionistically_2 | Iris.BI.embed_intuitionistically_2 | |
| embed_intuitionistically_if | Iris.BI.embed_intuitionistically_if | |
| embed_intuitionistically_if_2 | Iris.BI.embed_intuitionistically_if_2 | |
| embed_laterN | Iris.BI.embed_laterN | |
| embed_mono | Iris.BI.embed_mono | |
| embed_ne | Iris.BI.embed_ne | |
| embed_or | Iris.BI.embed_or | |
| embed_or_homomorphism | Iris.BI.embed_or_homomorphism | |
| embed_persistent | Iris.BI.embed_persistent | |
| embed_persistently | Iris.BI.embed_persistently | |
| embed_persistently_if | Iris.BI.embed_persistently_if | |
| embed_plain | Iris.BI.embed_plain | |
| embed_plainly | Iris.BI.embed_plainly | |
| embed_plainly_if | Iris.BI.embed_plainly_if | |
| embed_proper | iris-lean has no setoid `Proper` instances; `embed_congr` is the `≡`-respecting lemma. | |
| embed_pure | Iris.BI.embed_pure | |
| embed_sep | Iris.BI.embed_sep | |
| embed_sep_entails_homomorphism | Iris.BI.embed_sep_entails_homomorphism | |
| embed_sep_homomorphism | Iris.BI.embed_sep_homomorphism | |
| embed_si_pure | Iris.BI.embed_si_pure | |
| embed_timeless | Iris.BI.embed_timeless | |
| embed_wand | Iris.BI.embed_wand | |
| embed_wand_2 | Iris.BI.embed_wand_2 | |
| embed_wand_iff | Iris.BI.embed_wand_iff |
| Rocq Name | Status | Details |
|---|---|---|
| BiAffine | Iris.BI.BIAffine | |
| BiLaterContractive | Iris.BI.BILaterContractive | |
| BiLöb | Iris.BI.BILoeb | |
| BiPersistentlyForall | Iris.BI.BIPersistentlyForall | |
| BiPositive | Iris.BI.BIPositive | |
| BiPureForall | BIPureForall is provable for all BIs using classical logic, see pure_forall_2 |
| Rocq Name | Status | Details |
|---|---|---|
| BiLaterMixin | ||
| BiMixin | ||
| BiPersistentlyMixin | ||
| bi | ||
| bi.and_elim_l | ||
| bi.and_elim_r | ||
| bi.and_intro | ||
| bi.and_ne | ||
| bi.emp_sep_1 | ||
| bi.emp_sep_2 | ||
| bi.entails_po | ||
| bi.equiv_entails | ||
| bi.impl_elim_l' | ||
| bi.impl_intro_r | ||
| bi.impl_ne | ||
| bi.later_exist_false | ||
| bi.later_false_em | ||
| bi.later_forall_2 | ||
| bi.later_intro | ||
| bi.later_mono | ||
| bi.later_ne | ||
| bi.later_persistently_1 | ||
| bi.later_persistently_2 | ||
| bi.later_sep_1 | ||
| bi.later_sep_2 | ||
| bi.or_elim | ||
| bi.or_intro_l | ||
| bi.or_intro_r | ||
| bi.or_ne | ||
| bi.persistently_and_2 | ||
| bi.persistently_and_sep_elim | ||
| bi.persistently_emp_2 | ||
| bi.persistently_exist_1 | ||
| bi.persistently_idemp_2 | ||
| bi.persistently_mono | ||
| bi.persistently_ne | ||
| bi.pure_elim' | ||
| bi.pure_intro | ||
| bi.pure_ne | ||
| bi.sep_assoc' | ||
| bi.sep_comm' | ||
| bi.sep_mono | ||
| bi.sep_ne | ||
| bi.wand_elim_l' | ||
| bi.wand_intro_r | ||
| bi.wand_ne | ||
| bi_cofe | ||
| bi_inhabited | ||
| bi_later_mixin_id | ||
| bi_ofeO | ||
| bi_persistently_mixin_discrete | ||
| bi_rewrite_relation | ||
| bi.exist_elim | Iris.BI.exists_elim | |
| bi.exist_intro | Iris.BI.exists_intro | |
| bi.exist_ne | Iris.BI.exists_ne | |
| bi.forall_elim | Iris.BI.forall_elim | |
| bi.forall_intro | Iris.BI.forall_intro | |
| bi.forall_ne | Iris.BI.forall_ne | |
| bi.persistently_absorbing | Iris.BI.persistently_absorbing | |
| bi_emp_valid | Iris.BI.BIBase.EmpValid |
| Rocq Name | Status | Details |
|---|---|---|
| sigT_equivI | ||
| sum_equivI | ||
| absorbingly_internal_eq | Iris.BI.absorbingly_internalEq | |
| affinely_internal_eq_wand_iff | Iris.BI.affinely_internalEq_wandIff | |
| contractive_internal_eq | Iris.BI.contractive_internalEq | |
| csum_equivI | Iris.BI.csum_equivI | |
| discrete_eq | Iris.BI.discrete_eq | |
| discrete_eq_1 | Iris.BI.discrete_eq_mp | |
| discrete_fun_equivI | Iris.BI.discreteFun_equivI | |
| eq_timeless | Iris.BI.eq_timeless | |
| equiv_internal_eq | Iris.BI.internalEq.of_equiv | |
| excl_equivI | Iris.BI.excl_equivI_excl | |
| f_equivI | Iris.BI.internalEq.of_internalEquiv_ne | |
| f_equivI_contractive | Iris.BI.f_equivI_contractive | |
| fun_extI | Iris.BI.fun_extI | |
| internal_eq | Iris.internalEq | |
| internal_eq_absorbing | Iris.BI.internalEq_absorbing | |
| internal_eq_entails | Iris.BI.internalEq_entails | |
| internal_eq_iff | Iris.BI.internalEq_iff | |
| internal_eq_ne | Iris.BI.internalEq.instInternalEq_ne | |
| internal_eq_persistent | Iris.BI.internalEq_persistent | |
| internal_eq_proper | Derivable from internal_eq_ne with NonExpansive.eqv | |
| internal_eq_refl | Iris.BI.internalEq.refl | |
| internal_eq_rewrite | Iris.BI.internalEq.rewrite | |
| internal_eq_rewrite' | Iris.BI.internalEq.rewrite' | |
| internal_eq_rewrite_contractive | Iris.BI.internalEq_rewrite_contractive | |
| internal_eq_rewrite_contractive' | Iris.BI.internalEq_rewrite_contractive' | |
| internal_eq_soundness | Iris.BI.internalEq_soundness | |
| internal_eq_sym | Iris.BI.internalEq.symm | |
| internal_eq_trans | Iris.BI.internalEq.trans | |
| internal_eq_wand_iff | Iris.BI.internalEq_wandIff | |
| later_equivI | Iris.BI.later_equivI | |
| later_equivI_1 | Iris.BI.later_equivI_mp | |
| later_equivI_2 | Iris.BI.later_equivI_mpr | |
| later_equivI_prop_2 | Iris.BI.later_equivI_prop_mpr | |
| ne_2_internal_eq | Iris.BI.ne_2_internalEq | |
| ne_internal_eq | Iris.BI.ne_internalEq | |
| ofe_morO_equivI | Iris.BI.ofeMorO_equivI | |
| option_equivI | Iris.BI.option_some_equivI | |
| persistently_internal_eq | Iris.BI.persistently_internalEq | |
| prod_equivI | Iris.BI.prod_equivI | |
| prop_ext_si_emp_valid | Iris.BI.prop_ext_siEmpValid_equiv | |
| prop_ext_si_emp_valid_2 | Iris.BI.prop_ext_siEmpValid_mpr | |
| pure_internal_eq | Iris.BI.internalEq.of_pure | |
| sbi_later_contractive | Iris.BI.sbi_later_contractive | |
| sbi_prop_ext_mixin | Included in Sbi. | |
| si_pure_internal_eq | Iris.BI.siPure_internalEq | |
| sig_equivI | Iris.BI.sig_equivI | |
| sig_equivI_1 | Iris.BI.sig_equivI_mp |
| Rocq Name | Status | Details |
|---|---|---|
| aacc_aacc | ||
| aacc_aupd | ||
| aacc_aupd_abort | ||
| aacc_aupd_commit | ||
| aacc_intro | ||
| atomic_acc | ||
| atomic_acc_mask | ||
| atomic_acc_mask_weaken | ||
| atomic_acc_ne | ||
| atomic_acc_wand | ||
| atomic_update | ||
| atomic_update_aux | ||
| atomic_update_def | ||
| atomic_update_mask_weaken | ||
| atomic_update_ne | ||
| atomic_update_pre | ||
| atomic_update_pre_mono | ||
| atomic_update_unseal | ||
| aupd_aacc | ||
| aupd_intro | ||
| aupd_unfold | ||
| elim_acc_aacc | ||
| elim_mod_aupd | ||
| elim_modal_acc | ||
| tac_aupd_intro |
| Rocq Name | Status | Details |
|---|---|---|
| coreP | ||
| coreP_affine | ||
| coreP_elim | ||
| coreP_entails | ||
| coreP_entails' | ||
| coreP_flip_mono | ||
| coreP_intro | ||
| coreP_mono | ||
| coreP_ne | ||
| coreP_persistent | ||
| coreP_proper | ||
| coreP_wand |
| Rocq Name | Status | Details |
|---|---|---|
| affine_em.and_sep | ||
| affine_em.sep_dup | ||
| inv.A | ||
| inv.A_alloc | ||
| inv.A_persistent | ||
| inv.B | ||
| inv.I | ||
| inv.P | ||
| inv.contradiction | ||
| inv.contradiction' | ||
| inv.elim_fupd0_fupd1 | ||
| inv.elim_fupd_fupd | ||
| inv.exists_split_fupd0 | ||
| inv.finished_contradiction | ||
| inv.fupd_frame_r | ||
| inv.fupd_mono' | ||
| inv.fupd_proper | ||
| inv.inv_fupd' | ||
| inv.invariant_contradiction | ||
| inv.mask | ||
| inv.saved | ||
| inv.saved_A | ||
| inv.saved_NA | ||
| inv.saved_alloc | ||
| inv.saved_cast | ||
| inv.saved_persistent | ||
| later_credits_plain.contradiction | ||
| later_credits_plain.laterN_False | ||
| later_credits_plain.lc_fupd_elim_later_keep | ||
| linear.elim_fupd_fupd | ||
| linear.fupd_frame_r | ||
| linear.fupd_mono' | ||
| linear.fupd_proper | ||
| linear.leak | ||
| linear.mask | ||
| löb_em.later_anything | ||
| löb_em.later_inconsistent | ||
| savedprop.A | ||
| savedprop.A_alloc | ||
| savedprop.bupd_mono' | ||
| savedprop.contradiction | ||
| savedprop.elim_modal_bupd | ||
| savedprop.saved_A | ||
| savedprop.saved_NA |
| Rocq Name | Status | Details |
|---|---|---|
| fixpoint_absorbing | Iris.fixpoint_absorbing | |
| fixpoint_affine | Iris.fixpoint_affine | |
| fixpoint_persistent | Iris.fixpoint_persistent | |
| fixpoint_persistent_absoring | Iris.fixpoint_persistent_absorbing | |
| fixpoint_persistent_affine | Iris.fixpoint_persistent_affine | |
| fixpoint_plain | Iris.fixpoint_plain | |
| fixpoint_plain_absoring | Iris.fixpoint_plain_absorbing | |
| fixpoint_plain_affine | Iris.fixpoint_plain_affine |
| Rocq Name | Status | Details |
|---|---|---|
| Private_paco_mono | ||
| Private_wf_pred_mono | ||
| greatest_fixpoint_ne | ||
| greatest_fixpoint_proper | ||
| least_fixpoint_ne | ||
| least_fixpoint_proper | ||
| BiMonoPred | Iris.BIMonoPred | |
| bi_greatest_fixpoint | Iris.bi_greatest_fixpoint | |
| bi_least_fixpoint | Iris.bi_least_fixpoint | |
| greatest_fixpoint_absorbing | Iris.greatest_fixpoint_absorbing | |
| greatest_fixpoint_coind | Iris.greatest_fixpoint_coind | |
| greatest_fixpoint_coiter | Iris.greatest_fixpoint_coiter | |
| greatest_fixpoint_ne' | Iris.instNonExpansiveBi_greatest_fixpoint | |
| greatest_fixpoint_ne_outer | Iris.greatest_fixpoint_ne_outer | |
| greatest_fixpoint_paco | Iris.greatest_fixpoint_paco | |
| greatest_fixpoint_strong_mono | Iris.greatest_fixpoint_strong_mono | |
| greatest_fixpoint_unfold | Iris.greatest_fixpoint_unfold | |
| greatest_fixpoint_unfold_1 | Iris.greatest_fixpoint_unfold_mp | |
| greatest_fixpoint_unfold_2 | Iris.greatest_fixpoint_unfold_mpr | |
| least_fixpoint_absorbing | Iris.least_fixpoint_absorbing | |
| least_fixpoint_affine | Iris.least_fixpoint_affine | |
| least_fixpoint_ind | Iris.least_fixpoint_ind | |
| least_fixpoint_ind_wf | Iris.least_fixpoint_ind_wf | |
| least_fixpoint_iter | Iris.least_fixpoint_iter | |
| least_fixpoint_ne' | Iris.instNonExpansiveBi_least_fixpoint | |
| least_fixpoint_persistent_absorbing | Iris.least_fixpoint_persistent_absorbing | |
| least_fixpoint_persistent_affine | Iris.least_fixpoint_persistent_affine | |
| least_fixpoint_strong_mono | Iris.least_fixpoint_strong_mono | |
| least_fixpoint_unfold | Iris.least_fixpoint_unfold | |
| least_fixpoint_unfold_1 | Iris.least_fixpoint_unfold_mp | |
| least_fixpoint_unfold_2 | Iris.least_fixpoint_unfold_mpr |
| Rocq Name | Status | Details |
|---|---|---|
| Fractional_proper | ||
| FrameFractionalQp | ||
| as_fractional_embed | ||
| combine_sep_as_fractional | ||
| combine_sep_as_fractional_half | ||
| fractional_big_sepL | ||
| fractional_big_sepL2 | ||
| fractional_big_sepM | ||
| fractional_big_sepMS | ||
| fractional_big_sepS | ||
| fractional_embed | ||
| fractional_internal_fractional | ||
| fractional_sep | ||
| frame_fractional | ||
| frame_fractional_qp_add_l | ||
| frame_fractional_qp_add_r | ||
| frame_fractional_qp_half | ||
| internal_fractional | ||
| internal_fractional_affine | ||
| internal_fractional_iff | ||
| internal_fractional_ne | ||
| internal_fractional_persistent | ||
| internal_fractional_proper | ||
| persistent_fractional | ||
| AsFractional | Iris.AsFractional | |
| Fractional | Iris.Fractional | |
| fractional_as_fractional | Iris.fractional_as_fractional | |
| fractional_half | Iris.fractional_half | |
| fractional_merge | Iris.fractional_merge | |
| fractional_split | Iris.fractional_split | |
| from_sep_fractional | Iris.fromSepFractional | |
| from_sep_fractional_half | Iris.fromSepFractionalHalf | |
| into_sep_fractional | Iris.intoSepFractional | |
| into_sep_fractional_half | Iris.intoSepFractionalHalf |
| Rocq Name | Status | Details |
|---|---|---|
| IntoLaterable | ||
| Laterable | ||
| big_sepL_laterable | ||
| big_sep_sepL_laterable | ||
| exist_laterable | ||
| from_modal_make_laterable | ||
| into_laterable_fallback | ||
| into_laterable_laterable | ||
| intuitionistic_laterable | ||
| later_laterable | ||
| laterable_alt | ||
| laterable_proper | ||
| make_laterable | ||
| make_laterable_elim | ||
| make_laterable_except_0 | ||
| make_laterable_flip_mono' | ||
| make_laterable_idemp | ||
| make_laterable_intro | ||
| make_laterable_intro' | ||
| make_laterable_intuitionistic_wand | ||
| make_laterable_laterable | ||
| make_laterable_mono | ||
| make_laterable_mono' | ||
| make_laterable_ne | ||
| make_laterable_proper | ||
| make_laterable_sep | ||
| make_laterable_wand | ||
| modality_make_laterable | ||
| modality_make_laterable_mixin | ||
| persistent_laterable | ||
| sep_laterable | ||
| timeless_laterable |
| Rocq Name | Status | Details |
|---|---|---|
| bi_nsteps | ||
| bi_nsteps_O | ||
| bi_nsteps_add_inv | ||
| bi_nsteps_inv_r | ||
| bi_nsteps_l | ||
| bi_nsteps_ne | ||
| bi_nsteps_once | ||
| bi_nsteps_once_inv | ||
| bi_nsteps_proper | ||
| bi_nsteps_r | ||
| bi_nsteps_timeless | ||
| bi_nsteps_trans | ||
| bi_rtc | ||
| bi_rtc_affine | ||
| bi_rtc_ind_l | ||
| bi_rtc_inv | ||
| bi_rtc_l | ||
| bi_rtc_ne | ||
| bi_rtc_nsteps | ||
| bi_rtc_once | ||
| bi_rtc_persistent | ||
| bi_rtc_pre | ||
| bi_rtc_pre_mono | ||
| bi_rtc_proper | ||
| bi_rtc_r | ||
| bi_rtc_refl | ||
| bi_rtc_strong_ind_l | ||
| bi_rtc_tc | ||
| bi_rtc_timeless | ||
| bi_rtc_trans | ||
| bi_rtc_unfold | ||
| bi_tc | ||
| bi_tc_absorbing | ||
| bi_tc_affine | ||
| bi_tc_ind_l | ||
| bi_tc_l | ||
| bi_tc_ne | ||
| bi_tc_nsteps | ||
| bi_tc_once | ||
| bi_tc_persistent | ||
| bi_tc_pre | ||
| bi_tc_pre_mono | ||
| bi_tc_proper | ||
| bi_tc_r | ||
| bi_tc_rtc | ||
| bi_tc_rtc_l | ||
| bi_tc_rtc_r | ||
| bi_tc_strong_ind_l | ||
| bi_tc_timeless | ||
| bi_tc_trans | ||
| bi_tc_unfold |
| Rocq Name | Status | Details |
|---|---|---|
| BiIndexBottom | ||
| Objective | ||
| absorbingly_if_objective | ||
| absorbingly_objective | ||
| affinely_if_objective | ||
| affinely_objective | ||
| and_objective | ||
| biIndex | ||
| big_sepL_objective | ||
| big_sepMS_objective | ||
| big_sepM_objective | ||
| big_sepS_objective | ||
| bupd_objective | ||
| embed_objective | ||
| emp_objective | ||
| except0_objective | ||
| exists_objective | ||
| forall_objective | ||
| fupd_objective | ||
| impl_objective | ||
| internal_eq_objective | ||
| intuitionistically_if_objective | ||
| intuitionistically_objective | ||
| laterN_objective | ||
| later_objective | ||
| monPred | ||
| monPredI | ||
| monPredO | ||
| monPred_absorbing | ||
| monPred_affine | ||
| monPred_and_unseal | ||
| monPred_at_absorbing | ||
| monPred_at_absorbingly | ||
| monPred_at_absorbingly_if | ||
| monPred_at_affine | ||
| monPred_at_affinely | ||
| monPred_at_affinely_if | ||
| monPred_at_and | ||
| monPred_at_big_sepL | ||
| monPred_at_big_sepM | ||
| monPred_at_big_sepMS | ||
| monPred_at_big_sepS | ||
| monPred_at_bupd | ||
| monPred_at_dist | ||
| monPred_at_embed | ||
| monPred_at_emp | ||
| monPred_at_emp_valid | ||
| monPred_at_entails | ||
| monPred_at_equiv | ||
| monPred_at_except_0 | ||
| monPred_at_exist | ||
| monPred_at_flip_mono | ||
| monPred_at_forall | ||
| monPred_at_fupd | ||
| monPred_at_impl | ||
| monPred_at_in | ||
| monPred_at_internal_eq | ||
| monPred_at_intuitionistically | ||
| monPred_at_intuitionistically_if | ||
| monPred_at_later | ||
| monPred_at_laterN | ||
| monPred_at_mono | ||
| monPred_at_monoid_and_homomorphism | ||
| monPred_at_monoid_or_homomorphism | ||
| monPred_at_monoid_sep_homomorphism | ||
| monPred_at_ne | ||
| monPred_at_objectively | ||
| monPred_at_or | ||
| monPred_at_persistent | ||
| monPred_at_persistently | ||
| monPred_at_persistently_if | ||
| monPred_at_plain | ||
| monPred_at_plainly | ||
| monPred_at_proper | ||
| monPred_at_pure | ||
| monPred_at_sep | ||
| monPred_at_subjectively | ||
| monPred_at_timeless | ||
| monPred_at_wand | ||
| monPred_bi_affine | ||
| monPred_bi_bupd | ||
| monPred_bi_bupd_fupd | ||
| monPred_bi_bupd_sbi | ||
| monPred_bi_embed | ||
| monPred_bi_embed_bupd | ||
| monPred_bi_embed_emp | ||
| monPred_bi_embed_fupd | ||
| monPred_bi_embed_later | ||
| monPred_bi_embed_sbi | ||
| monPred_bi_fupd | ||
| monPred_bi_fupd_sbi | ||
| monPred_bi_later_contractive | ||
| monPred_bi_later_mixin | ||
| monPred_bi_löb | ||
| monPred_bi_mixin | ||
| monPred_bi_persistently_forall | ||
| monPred_bi_persistently_mixin | ||
| monPred_bi_positive | ||
| monPred_bi_pure_forall | ||
| monPred_bupd_mixin | ||
| monPred_bupd_unseal | ||
| monPred_cofe | ||
| monPred_defs.monPred_and | ||
| monPred_defs.monPred_and_aux | ||
| monPred_defs.monPred_and_def | ||
| monPred_defs.monPred_and_unseal | ||
| monPred_defs.monPred_bupd | ||
| monPred_defs.monPred_bupd_aux | ||
| monPred_defs.monPred_bupd_def | ||
| monPred_defs.monPred_bupd_unseal | ||
| monPred_defs.monPred_embed | ||
| monPred_defs.monPred_embed_aux | ||
| monPred_defs.monPred_embed_def | ||
| monPred_defs.monPred_embed_unseal | ||
| monPred_defs.monPred_emp | ||
| monPred_defs.monPred_emp_aux | ||
| monPred_defs.monPred_emp_def | ||
| monPred_defs.monPred_emp_unseal | ||
| monPred_defs.monPred_entails | ||
| monPred_defs.monPred_exist | ||
| monPred_defs.monPred_exist_aux | ||
| monPred_defs.monPred_exist_def | ||
| monPred_defs.monPred_exist_unseal | ||
| monPred_defs.monPred_forall | ||
| monPred_defs.monPred_forall_aux | ||
| monPred_defs.monPred_forall_def | ||
| monPred_defs.monPred_forall_unseal | ||
| monPred_defs.monPred_fupd | ||
| monPred_defs.monPred_fupd_aux | ||
| monPred_defs.monPred_fupd_def | ||
| monPred_defs.monPred_fupd_unseal | ||
| monPred_defs.monPred_impl | ||
| monPred_defs.monPred_impl_aux | ||
| monPred_defs.monPred_impl_def | ||
| monPred_defs.monPred_impl_unseal | ||
| monPred_defs.monPred_in | ||
| monPred_defs.monPred_in_aux | ||
| monPred_defs.monPred_in_def | ||
| monPred_defs.monPred_in_unseal | ||
| monPred_defs.monPred_later | ||
| monPred_defs.monPred_later_aux | ||
| monPred_defs.monPred_later_def | ||
| monPred_defs.monPred_later_unseal | ||
| monPred_defs.monPred_objectively | ||
| monPred_defs.monPred_objectively_aux | ||
| monPred_defs.monPred_objectively_def | ||
| monPred_defs.monPred_objectively_unseal | ||
| monPred_defs.monPred_or | ||
| monPred_defs.monPred_or_aux | ||
| monPred_defs.monPred_or_def | ||
| monPred_defs.monPred_or_unseal | ||
| monPred_defs.monPred_persistently | ||
| monPred_defs.monPred_persistently_aux | ||
| monPred_defs.monPred_persistently_def | ||
| monPred_defs.monPred_persistently_unseal | ||
| monPred_defs.monPred_pure | ||
| monPred_defs.monPred_pure_aux | ||
| monPred_defs.monPred_pure_def | ||
| monPred_defs.monPred_pure_unseal | ||
| monPred_defs.monPred_sep | ||
| monPred_defs.monPred_sep_aux | ||
| monPred_defs.monPred_sep_def | ||
| monPred_defs.monPred_sep_unseal | ||
| monPred_defs.monPred_si_emp_valid | ||
| monPred_defs.monPred_si_emp_valid_aux | ||
| monPred_defs.monPred_si_emp_valid_def | ||
| monPred_defs.monPred_si_emp_valid_unseal | ||
| monPred_defs.monPred_si_pure | ||
| monPred_defs.monPred_si_pure_aux | ||
| monPred_defs.monPred_si_pure_def | ||
| monPred_defs.monPred_si_pure_unseal | ||
| monPred_defs.monPred_subjectively | ||
| monPred_defs.monPred_subjectively_aux | ||
| monPred_defs.monPred_subjectively_def | ||
| monPred_defs.monPred_subjectively_unseal | ||
| monPred_defs.monPred_unseal | ||
| monPred_defs.monPred_upclosed | ||
| monPred_defs.monPred_wand | ||
| monPred_defs.monPred_wand_aux | ||
| monPred_defs.monPred_wand_def | ||
| monPred_defs.monPred_wand_unseal | ||
| monPred_dist | ||
| monPred_dist' | ||
| monPred_embed_unseal | ||
| monPred_embedding_mixin | ||
| monPred_emp_unfold | ||
| monPred_emp_unseal | ||
| monPred_equiv | ||
| monPred_equiv' | ||
| monPred_equivI | ||
| monPred_exist_unseal | ||
| monPred_forall_unseal | ||
| monPred_fupd_mixin | ||
| monPred_fupd_unseal | ||
| monPred_impl_force | ||
| monPred_impl_unseal | ||
| monPred_in_absorbing | ||
| monPred_in_elim | ||
| monPred_in_flip_mono | ||
| monPred_in_intro | ||
| monPred_in_mono | ||
| monPred_in_persistent | ||
| monPred_in_proper | ||
| monPred_in_timeless | ||
| monPred_internal_eq_unfold | ||
| monPred_later_unseal | ||
| monPred_objectively_absorbing | ||
| monPred_objectively_affine | ||
| monPred_objectively_and | ||
| monPred_objectively_big_sepL | ||
| monPred_objectively_big_sepL_entails | ||
| monPred_objectively_big_sepM | ||
| monPred_objectively_big_sepMS | ||
| monPred_objectively_big_sepMS_entails | ||
| monPred_objectively_big_sepM_entails | ||
| monPred_objectively_big_sepS | ||
| monPred_objectively_big_sepS_entails | ||
| monPred_objectively_elim | ||
| monPred_objectively_embed | ||
| monPred_objectively_emp | ||
| monPred_objectively_exist | ||
| monPred_objectively_flip_mono' | ||
| monPred_objectively_forall | ||
| monPred_objectively_idemp | ||
| monPred_objectively_mono | ||
| monPred_objectively_mono' | ||
| monPred_objectively_monoid_and_homomorphism | ||
| monPred_objectively_monoid_sep_entails_homomorphism | ||
| monPred_objectively_monoid_sep_homomorphism | ||
| monPred_objectively_ne | ||
| monPred_objectively_or | ||
| monPred_objectively_persistent | ||
| monPred_objectively_plain | ||
| monPred_objectively_proper | ||
| monPred_objectively_pure | ||
| monPred_objectively_sep | ||
| monPred_objectively_sep_2 | ||
| monPred_objectively_timeless | ||
| monPred_objectively_unfold | ||
| monPred_ofe_mixin | ||
| monPred_or_unseal | ||
| monPred_persistent | ||
| monPred_persistently_unseal | ||
| monPred_pure_unfold | ||
| monPred_pure_unseal | ||
| monPred_sbi | ||
| monPred_sbi_emp_valid_exist | ||
| monPred_sbi_mixin | ||
| monPred_sbi_prop_ext_mixin | ||
| monPred_sep_unseal | ||
| monPred_si_emp_valid_unfold | ||
| monPred_si_emp_valid_unseal | ||
| monPred_si_pure_unfold | ||
| monPred_si_pure_unseal | ||
| monPred_sig | ||
| monPred_sig_monPred | ||
| monPred_sig_ne | ||
| monPred_sig_proper | ||
| monPred_subjectively_absorbing | ||
| monPred_subjectively_affine | ||
| monPred_subjectively_and | ||
| monPred_subjectively_exist | ||
| monPred_subjectively_flip_mono' | ||
| monPred_subjectively_forall | ||
| monPred_subjectively_idemp | ||
| monPred_subjectively_intro | ||
| monPred_subjectively_mono | ||
| monPred_subjectively_mono' | ||
| monPred_subjectively_ne | ||
| monPred_subjectively_or | ||
| monPred_subjectively_persistent | ||
| monPred_subjectively_plain | ||
| monPred_subjectively_proper | ||
| monPred_subjectively_sep | ||
| monPred_subjectively_timeless | ||
| monPred_subjectively_unfold | ||
| monPred_unseal | ||
| monPred_unseal_bi | ||
| monPred_wand_force | ||
| monPred_wand_unseal | ||
| objective_objectively | ||
| objective_subjectively | ||
| objectively_objective | ||
| or_objective | ||
| persistently_if_objective | ||
| persistently_objective | ||
| plainly_if_objective | ||
| plainly_objective | ||
| pure_objective | ||
| sep_objective | ||
| si_pure_objective | ||
| sig_monPred | ||
| sig_monPred_ne | ||
| sig_monPred_proper | ||
| sig_monPred_sig | ||
| subjectively_objective | ||
| wand_objective |
| Rocq Name | Status | Details |
|---|---|---|
| big_sepM2_empty_plain | ||
| big_sepM2_plain | ||
| big_sepM2_plainly | ||
| big_sepMS_empty_plain | ||
| big_sepMS_plain | ||
| big_sepMS_plainly | ||
| Plain | Iris.BI.Plain | |
| Plain_proper | Derivable from BI. | |
| absorbingly_elim_plainly | Iris.BI.absorbingly_elim_plainly | |
| absorbingly_plain | Iris.BI.absorbingly_plain | |
| affinely_plain | Iris.BI.affinely_plain | |
| affinely_plainly_elim | Iris.BI.affinely_plainly_elim | |
| and_plain | Iris.BI.and_plain | |
| and_sep_plainly | Iris.BI.and_sep_plainly | |
| big_andL_nil_plain | Iris.BI.bigAndL_nil_plain | |
| big_andL_plain | Iris.BI.bigAndL_plain | |
| big_andL_plainly | Iris.BI.bigAndL_plainly | |
| big_orL_nil_plain | Iris.BI.bigOrL_nil_plain | |
| big_orL_plain | Iris.BI.bigOrL_plain | |
| big_orL_plainly | Iris.BI.bigOrL_plainly | |
| big_sepL2_nil_plain | Iris.BI.bigSepL2_nil_plain | |
| big_sepL2_plain | Iris.BI.bigSepL2_plain | |
| big_sepL2_plainly | Iris.BI.bigSepL2_plainly | |
| big_sepL_nil_plain | Iris.BI.bigSepL_nil_plain | |
| big_sepL_plain | Iris.BI.bigSepL_plain | |
| big_sepL_plainly | Iris.BI.bigSepL_plainly | |
| big_sepM_empty_plain | Iris.BI.bigSepM_empty_plain | |
| big_sepM_plain | Iris.BI.bigSepM_plain | |
| big_sepM_plainly | Iris.BI.bigSepM_plainly | |
| big_sepS_empty_plain | Iris.BI.bigSepS_empty_plain | |
| big_sepS_plain | Iris.BI.bigSepS_plain | |
| big_sepS_plainly | Iris.BI.bigSepS_plainly | |
| emp_plain | Iris.BI.emp_plain | |
| except_0_plain | Iris.BI.except0_plain | |
| except_0_plainly | Iris.BI.except0_plainly | |
| except_0_plainly_1 | Iris.BI.except0_plainly_1 | |
| exist_plain | Iris.BI.exists_plain | |
| forall_plain | Iris.BI.forall_plain | |
| from_option_plain | Iris.BI.from_option_plain | |
| impl_persistent | Iris.BI.impl_persistent | |
| impl_plain | Iris.BI.impl_plain | |
| impl_wand_affinely_plainly | Iris.BI.impl_wand_affinely_plainly | |
| impl_wand_plainly | Iris.BI.impl_wand_plainly | |
| impl_wand_plainly_2 | Iris.BI.impl_wand_plainly_2 | |
| internal_eq_plain | Iris.BI.internalEq_plain | |
| internal_eq_timeless | Iris.BI.internalEq_timeless | |
| intuitionistically_plain | Iris.BI.intuitionistically_plain | |
| intuitionistically_plainly | Iris.BI.intuitionistically_plainly | |
| intuitionistically_plainly_elim | Iris.BI.intuitionistically_plainly_elim | |
| laterN_plain | Iris.BI.laterN_plain | |
| laterN_plainly | Iris.BI.laterN_plainly | |
| laterN_plainly_if | Iris.BI.laterN_plainlyIf | |
| later_plain | Iris.BI.later_plain | |
| later_plainly | Iris.later_plainly | |
| later_plainly_1 | Iris.BI.later_plainly_mp | |
| later_plainly_2 | Iris.BI.later_plainly_mpr | |
| later_plainly_if | Iris.BI.later_plainlyIf | |
| limit_preserving_Plain | Iris.BI.limitPreserving_plain | |
| or_plain | Iris.BI.or_plain | |
| persistently_elim_plainly | Iris.BI.persistently_elim_plainly | |
| persistently_if_elim_plainly | Iris.BI.persistently_if_elim_plainly | |
| persistently_impl_plainly | Iris.persistently_impl_plainly | |
| persistently_plain | Iris.BI.persistently_plain | |
| persistently_wand_affinely_plainly | Iris.BI.persistently_wand_affinely_plainly | |
| plain_persistent | Iris.BI.plain_persistent | |
| plain_plainly | Iris.BI.plain_plainly | |
| plain_plainly_2 | Iris.BI.plain_plainly_2 | |
| plainly | Iris.instPlainlySbi | |
| plainly_True_alt | Iris.BI.plainly_true_alt | |
| plainly_True_emp | Iris.BI.plainly_true_emp | |
| plainly_absorb | Iris.plainly_absorb | |
| plainly_absorbing | Iris.BI.plainly_absorbing | |
| plainly_affinely_elim | Iris.BI.plainly_affinely_elim | |
| plainly_alt | Iris.BI.plainly_alt | |
| plainly_alt_absorbing | Iris.BI.plainly_alt_absorbing | |
| plainly_and | Iris.BI.plainly_and | |
| plainly_and_emp_elim | Iris.BI.plainly_and_emp_elim | |
| plainly_and_homomorphism | Iris.BI.plainly_and_homomorphism | |
| plainly_and_sep | Iris.BI.plainly_and_sep | |
| plainly_and_sep_assoc | Iris.BI.plainly_and_sep_assoc | |
| plainly_and_sep_elim | Iris.BI.plainly_and_sep_elim | |
| plainly_and_sep_l | Iris.BI.plainly_and_sep_left | |
| plainly_and_sep_l_1 | Iris.BI.plainly_and_sep_left_mp | |
| plainly_and_sep_r | Iris.BI.plainly_and_sep_right | |
| plainly_and_sep_r_1 | Iris.BI.plainly_and_sep_right_mp | |
| plainly_elim | Iris.BI.plainly_elim | |
| plainly_elim_persistently | Iris.plainly_elim_persistently | |
| plainly_emp | Iris.BI.plainly_emp | |
| plainly_emp_2 | Iris.BI.plainly_emp_2 | |
| plainly_emp_intro | Iris.plainly_emp_intro | |
| plainly_entails_l | Iris.BI.plainly_entails_left | |
| plainly_entails_r | Iris.BI.plainly_entails_right | |
| plainly_exist | Iris.BI.plainly_exists | |
| plainly_exist_1 | Iris.plainly_exist | |
| plainly_exist_2 | Iris.BI.plainly_exists_mpr | |
| plainly_flip_mono' | Use plainly_mono. | |
| plainly_forall | Iris.BI.plainly_forall | |
| plainly_forall_2 | Iris.plainly_forall | |
| plainly_idemp | Iris.BI.plainly_idem | |
| plainly_idemp_1 | Iris.BI.plainly_idem_mp | |
| plainly_idemp_2 | Iris.plainly_idem_mpr | |
| plainly_if | Iris.BI.BIBase.Plainly.plainlyIf | |
| plainly_if_absorbing | Iris.BI.plainly_if_absorbing | |
| plainly_if_and | Iris.BI.plainly_if_and | |
| plainly_if_exist | Iris.BI.plainly_if_exists | |
| plainly_if_exist_2 | Iris.BI.plainly_if_exists_2 | |
| plainly_if_flip_mono' | Use plainly_if_mono. | |
| plainly_if_idemp | Iris.BI.plainly_if_idem | |
| plainly_if_mono | Iris.plainly_if_mono | |
| plainly_if_mono' | Use plainly_if_mono. | |
| plainly_if_ne | Iris.instPlainlyIf_ne | |
| plainly_if_or | Iris.BI.plainly_if_or | |
| plainly_if_or_2 | Iris.BI.plainly_if_or_2 | |
| plainly_if_proper | Derivable from plainly_if_ne with NonExpansive.eqv | |
| plainly_if_pure | Iris.BI.plainly_if_pure | |
| plainly_if_sep_2 | Iris.BI.plainly_if_sep_2 | |
| plainly_impl | Iris.BI.plainly_imp | |
| plainly_impl_plainly | Iris.plainly_impl_plainly | |
| plainly_impl_wand | Iris.BI.plainly_impl_wand | |
| plainly_impl_wand_2 | Iris.BI.plainly_impl_wand_2 | |
| plainly_internal_eq | Iris.BI.plainly_internalEq | |
| plainly_into_absorbingly | Iris.BI.plainly_into_absorbingly | |
| plainly_intro | Iris.BI.plainly_intro | |
| plainly_intro' | Iris.BI.plainly_intro_plainly | |
| plainly_mono | Iris.plainly_mono | |
| plainly_mono' | Use plainly_mono. | |
| plainly_ne | Iris.instPlainly_ne | |
| plainly_or | Iris.BI.plainly_or | |
| plainly_or_2 | Iris.BI.plainly_or_mpr | |
| plainly_or_homomorphism | Iris.BI.plainly_or_homomorphism | |
| plainly_persistent | Iris.BI.plainly_persistent | |
| plainly_persistently_elim | Iris.BI.plainly_persistently_elim | |
| plainly_plain | Iris.BI.plainly_plain | |
| plainly_proper | Derivable from plainly_ne with NonExpansive.eqv | |
| plainly_pure | Iris.BI.plainly_pure | |
| plainly_sep | Iris.BI.plainly_sep | |
| plainly_sep_2 | Iris.BI.plainly_sep_2 | |
| plainly_sep_dup | Iris.BI.plainly_sep_dup | |
| plainly_sep_entails_homomorphism | Iris.BI.plainly_sep_entails_homomorphism | |
| plainly_sep_entails_weak_homomorphism | Iris.BI.plainly_sep_entails_weak_homomorphism | |
| plainly_sep_homomorphism | Iris.BI.plainly_sep_homomorphism | |
| plainly_sep_weak_homomorphism | Iris.BI.plainly_sep_weak_homomorphism | |
| plainly_si_pure | Iris.BI.plainly_siPure | |
| plainly_timeless | Iris.BI.plainly_timeless | |
| plainly_wand | Iris.BI.plainly_wand | |
| plainly_wand_affinely_plainly | Iris.BI.plainly_wand_affinely_plainly | |
| prop_ext | Iris.BI.prop_ext | |
| prop_ext_2 | Subsumed by `prop_ext_symm` | |
| pure_plain | Iris.BI.pure_plain | |
| sep_plain | Iris.BI.sep_plain | |
| siProp_plain | Iris.instPlainlySbi | |
| si_emp_valid_plain | Iris.BI.si_emp_valid_plain | |
| si_pure_plain | Iris.BI.si_pure_plain | |
| wand_persistent | Iris.BI.wand_persistent | |
| wand_plain | Iris.BI.wand_plain |
| Rocq Name | Status | Details |
|---|---|---|
| Sbi | Iris.Sbi | |
| SbiEmpValidExist | Iris.SbiEmpValidExist | |
| SbiMixin | Uses the Sbi typeclass. | |
| SbiPropExtMixin | Included in Sbi. | |
| SiEmpValid | Iris.SiEmpValid | |
| SiPure | Iris.SiPure | |
| absorbingly_si_pure | Iris.absorbingly_siPure | |
| affinely_si_pure_si_emp_valid | Iris.affinely_siPure_siEmpValid | |
| laterN_soundness | Iris.laterN_soundness | |
| later_soundness | Iris.later_soundness | |
| persistently_impl_si_pure | UPred.persistently_imp_uPredSiPure | |
| persistently_si_pure | Iris.persistently_siPure | |
| pure_soundness | Iris.pure_soundness | |
| si_emp_valid_affinely | Iris.siEmpValid_affinely | |
| si_emp_valid_affinely_2 | Iris.si_emp_valid_affinely_2 | |
| si_emp_valid_and | Iris.siEmpValid_and | |
| si_emp_valid_emp | Iris.siEmpValid_emp | |
| si_emp_valid_emp_valid | Iris.siEmpValid_emp_valid | |
| si_emp_valid_except_0 | Iris.siEmpValid_except0 | |
| si_emp_valid_exist | Iris.siEmpValid_exist | |
| si_emp_valid_exist_2 | Iris.siEmpValid_exist_mpr | |
| si_emp_valid_flip_mono' | Use siEmpValid_mono. | |
| si_emp_valid_forall | Iris.siEmpValid_forall | |
| si_emp_valid_impl_si_pure | Iris.siEmpValid_imp_siPure | |
| si_emp_valid_intuitionistically | Iris.siEmpValid_intuitionistically | |
| si_emp_valid_later | Iris.siEmpValid_later | |
| si_emp_valid_laterN | Iris.siEmpValid_laterN | |
| si_emp_valid_later_1 | UPred.uPredSiEmpValid_later_mp | |
| si_emp_valid_mono | UPred.uPredSiEmpValid_mono | |
| si_emp_valid_mono' | Use siEmpValid_mono. | |
| si_emp_valid_ne | UPred.uPredSiEmpValid_ne | |
| si_emp_valid_or | Iris.siEmpValid_or | |
| si_emp_valid_or_2 | Iris.siEmpValid_or_mpr | |
| si_emp_valid_persistently | Iris.siEmpValid_persistently | |
| si_emp_valid_proper | Derivable from siEmpValid_ne with NonExpansive.eqv. | |
| si_emp_valid_pure | Iris.siEmpValid_pure | |
| si_emp_valid_sep | Iris.siEmpValid_sep | |
| si_emp_valid_si_pure | UPred.uPredSiEmpValid_uPredSiPure | |
| si_emp_valid_timeless | Iris.siEmpValid_timeless | |
| si_emp_valid_wand_si_pure | Iris.siEmpValid_wand_siPure | |
| si_pure_absorbing | Iris.Sbi.siPure_absorbing | |
| si_pure_and | Iris.siPure_and | |
| si_pure_and_sep | Iris.siPure_and_sep | |
| si_pure_emp_valid | Iris.siPure_emp_valid | |
| si_pure_entails | Iris.siPure_entails | |
| si_pure_except_0 | Iris.siPure_except0 | |
| si_pure_exist | Iris.siPure_exist | |
| si_pure_flip_mono' | Use siPure_mono. | |
| si_pure_forall | Iris.siPure_forall | |
| si_pure_forall_2 | Iris.siPure_forall_mpr | |
| si_pure_iff | Iris.siPure_iff | |
| si_pure_impl | Iris.siPure_imp | |
| si_pure_impl_2 | UPred.uPredSiPure_imp_mpr | |
| si_pure_impl_iff_wand | Iris.siPure_iff_wandIff | |
| si_pure_impl_wand | Iris.siPure_imp_wand | |
| si_pure_inj | Iris.siPure_inj | |
| si_pure_later | UPred.uPredSiPure_later | |
| si_pure_laterN | Iris.siPure_laterN | |
| si_pure_mono | UPred.uPredSiPure_mono | |
| si_pure_mono' | Use siPure_mono. | |
| si_pure_ne | UPred.uPredSiPure_ne | |
| si_pure_or | Iris.siPure_or | |
| si_pure_persistent | Iris.siPure_persistent | |
| si_pure_proper | Iris.siPure_mono_bi | |
| si_pure_pure | Iris.siPure_pure | |
| si_pure_si_emp_valid | UPred.uPredSiPure_uPredSiEmpValid | |
| si_pure_si_emp_valid_elim | Iris.siPure_siEmpValid_elim | |
| si_pure_timeless | Iris.siPure_timeless | |
| siprop_sbi | Iris.instSbiSiProp | |
| siprop_sbi_emp_valid_exist | Iris.instSbiEmpValidExistSiProp | |
| siprop_sbi_mixin | Included in Sbi instance construction. | |
| siprop_sbi_prop_ext_mixin | Included in Sbi instance construction. |
| Rocq Name | Status | Details |
|---|---|---|
| SbiUnfold | ||
| SbiUnfold_closed | ||
| SbiUnfold_downclose | ||
| sbi_unfold_and | ||
| sbi_unfold_closed_weaken | ||
| sbi_unfold_closure_indicator.sbi_unfold_closure_indicator | ||
| sbi_unfold_emp_valid | ||
| sbi_unfold_entails | ||
| sbi_unfold_equiv | ||
| sbi_unfold_exist | ||
| sbi_unfold_forall | ||
| sbi_unfold_iff | ||
| sbi_unfold_iff_wand | ||
| sbi_unfold_impl | ||
| sbi_unfold_internal_cmra_valid | ||
| sbi_unfold_internal_eq | ||
| sbi_unfold_internal_included | ||
| sbi_unfold_later | ||
| sbi_unfold_maybe_downclose | ||
| sbi_unfold_or | ||
| sbi_unfold_pure | ||
| sbi_unfold_sep | ||
| sbi_unfold_si_pure | ||
| sbi_unfold_siprop | ||
| sbi_unfold_tceq | ||
| sbi_unfold_wand |
| Rocq Name | Status | Details |
|---|---|---|
| bi_texist | ||
| bi_texist_absorbing | ||
| bi_texist_affine | ||
| bi_texist_exist | ||
| bi_texist_ne | ||
| bi_texist_persistent | ||
| bi_texist_proper | ||
| bi_texist_timeless | ||
| bi_tforall | ||
| bi_tforall_absorbing | ||
| bi_tforall_forall | ||
| bi_tforall_ne | ||
| bi_tforall_persistent | ||
| bi_tforall_proper | ||
| bi_tforall_timeless |
| Rocq Name | Status | Details |
|---|---|---|
| BiFUpdSbi | ||
| big_sepL_bupd | ||
| big_sepM2_bupd | ||
| big_sepM2_fupd | ||
| big_sepMS_bupd | ||
| big_sepMS_fupd | ||
| big_sepM_fupd | ||
| big_sepS_bupd | ||
| big_sepS_fupd | ||
| bupd_or_homomorphism | ||
| fupd_or_homomorphism | ||
| fupd_plain_forall | ||
| fupd_plain_forall' | ||
| fupd_plain_forall_2 | ||
| fupd_plain_laterN | ||
| fupd_plainly_forall_2 | ||
| fupd_plainly_laterN | ||
| step_fupd_mask_frame_r | ||
| step_fupd_plain_forall | ||
| BUpd | Iris.BUpd | |
| BiBUpd | Iris.BIUpdate | |
| BiBUpdFUpd | Iris.BIUpdateFUpdate | |
| BiBUpdMixin | Included in BIUpdate typeclass. | |
| BiBUpdSbi | Iris.BIBUpdateSbi | |
| BiFUpd | Iris.BIFUpdate | |
| BiFUpdMixin | Included in BIFUpdate typeclass. | |
| FUpd | Iris.FUpd | |
| big_sepL2_fupd | Iris.BigSepL2.bigSepL2_fupd | |
| big_sepL_fupd | Iris.BigSepL2.bigSepL_fupd | |
| big_sepM_bupd | Iris.BigSepM.bigSepM_bupd | |
| bupd_absorbing | Iris.instAbsorbingBupd | |
| bupd_and | Iris.bupd_and | |
| bupd_elim | Iris.bupd_elim | |
| bupd_exist | Iris.bupd_exist | |
| bupd_flip_mono' | Use bupd_mono. | |
| bupd_forall | Iris.bupd_forall | |
| bupd_frame_l | Iris.bupd_frame_left | |
| bupd_frame_r | Iris.bupd_frame_right | |
| bupd_idemp | Iris.bupd_idem | |
| bupd_intro | Iris.bupd_intro | |
| bupd_mono | Iris.bupd_mono | |
| bupd_mono' | Use bupd_mono. | |
| bupd_ne | Iris.bupd_ne | |
| bupd_or | Iris.bupd_or | |
| bupd_plain | Iris.bupd_plain | |
| bupd_plain_forall | Iris.bupd_plain_forall | |
| bupd_plainly | Iris.bupd_plainly | |
| bupd_plainly_elim | Iris.bupd_plainly_elim | |
| bupd_proper | Derivable from bupd_ne with NonExpansive.eqv | |
| bupd_sep | Iris.bupd_sep | |
| bupd_sep_homomorphism | Iris.bupd_sep_homomorphism | |
| bupd_trans | Iris.bupd_trans | |
| bupd_wand_l | Iris.bupd_wand_left | |
| bupd_wand_r | Iris.bupd_wand_right | |
| except_0_bupd | Iris.except0_bupd | |
| except_0_fupd | Iris.except0_fupd | |
| fupd_absorbing | Iris.instAbsorbingFupd | |
| fupd_and | Iris.fupd_and | |
| fupd_elim | Iris.fupd_elim | |
| fupd_except_0 | Iris.fupd_except0 | |
| fupd_exist | Iris.fupd_exist | |
| fupd_flip_mono' | Use BIFUpdate.mono. | |
| fupd_forall | Iris.fupd_forall | |
| fupd_frame_l | Iris.fupd_frame_left | |
| fupd_frame_r | Iris.fupd_vs_frame_r | |
| fupd_idemp | Iris.fupd_idem | |
| fupd_intro | Iris.fupd_vs_intro | |
| fupd_keep_plain | Iris.fupd_keep_plain | |
| fupd_keep_plain_sep | Iris.fupd_keep_plain_sep | |
| fupd_keep_plainly | Iris.fupd_keep_plainly | |
| fupd_keep_si_pure | Iris.fupd_keep_si_pure | |
| fupd_mask_frame | Iris.fupd_mask_frame | |
| fupd_mask_frame_acc | Iris.fupd_mask_frame_acc | |
| fupd_mask_frame_r | Iris.fupd_vs_mask_frame_r | |
| fupd_mask_frame_r' | Iris.fupd_mask_frame_right_strong | |
| fupd_mask_intro | Iris.fupd_mask_intro | |
| fupd_mask_intro_discard | Iris.fupd_mask_intro_discard | |
| fupd_mask_intro_subseteq | Iris.fupd_mask_intro_subseteq | |
| fupd_mask_mono | Iris.fupd_mask_mono | |
| fupd_mask_subseteq | Iris.fupd_mask_subseteq | |
| fupd_mask_subseteq_emptyset_difference | Iris.fupd_mask_subseteq_emptyset_difference | |
| fupd_mask_weaken | Iris.fupd_mask_weaken | |
| fupd_mono | Iris.fupd_vs_mono | |
| fupd_mono' | Use BIFUpdate.mono. | |
| fupd_ne | Iris.fupd_vs_ne | |
| fupd_or | Iris.fupd_or | |
| fupd_plain_later | Iris.fupd_plain_later | |
| fupd_plain_mask | Iris.fupd_plain_mask | |
| fupd_plainly_later | Iris.fupd_plainly_later | |
| fupd_plainly_mask | Iris.fupd_plainly_mask | |
| fupd_proper | Derivable from BIFUpdate.ne with NonExpansive.eqv | |
| fupd_sep | Iris.fupd_sep | |
| fupd_sep_homomorphism | Iris.fupd_sep_homomorphism | |
| fupd_trans | Iris.fupd_vs_trans | |
| fupd_trans_frame | Iris.fupd_trans_frame | |
| fupd_wand_l | Iris.fupd_wand_left | |
| fupd_wand_r | Iris.fupd_wand_right | |
| step_fupdN_S_fupd | Iris.step_fupdN_S_fupd | |
| step_fupdN_add | Iris.step_fupdN_add | |
| step_fupdN_frame_l | Iris.step_fupdN_frame_left | |
| step_fupdN_intro | Iris.step_fupdN_intro | |
| step_fupdN_le | Iris.step_fupdN_le | |
| step_fupdN_mono | Iris.step_fupdN_mono | |
| step_fupdN_plain | Iris.step_fupdN_plain | |
| step_fupdN_wand | Iris.step_fupdN_wand | |
| step_fupd_frame_l | Iris.step_fupd_frame_left | |
| step_fupd_fupd | Iris.step_fupd_fupd | |
| step_fupd_intro | Iris.step_fupd_intro | |
| step_fupd_mask_mono | Iris.step_fupd_mask_mono | |
| step_fupd_plain | Iris.step_fupd_plain | |
| step_fupd_wand | Iris.step_fupd_wand |
| Rocq Name | Status | Details |
|---|---|---|
| Twp | ||
| Wp | ||
| stuckness | ||
| stuckness_le | ||
| stuckness_le_po |
▶
program_logic/177/297 (60%)| Rocq Name | Status | Details |
|---|---|---|
| adequate | Iris.ProgramLogic.adequate | |
| adequate_alt | Iris.ProgramLogic.adequate_alt | |
| adequate_tp_safe | Iris.ProgramLogic.adequate_tp_safe | |
| steps_sum | Iris.ProgramLogic.steps_sum | |
| wp_adequacy | Iris.ProgramLogic.wp_adequacy | |
| wp_adequacy_gen | Iris.ProgramLogic.wp_adequacy_gen | |
| wp_invariance | Iris.ProgramLogic.wp_invariance | |
| wp_invariance_gen | Iris.ProgramLogic.wp_invariance_gen | |
| wp_not_stuck | Iris.ProgramLogic.wp_not_stuck | |
| wp_step | Iris.ProgramLogic.wp_step | |
| wp_strong_adequacy | Iris.ProgramLogic.wp_strong_adequacy | |
| wp_strong_adequacy_gen | Iris.ProgramLogic.wp_strong_adequacy_gen | |
| wptp_postconditions | Iris.ProgramLogic.wptp_postconditions | |
| wptp_preservation | Iris.ProgramLogic.wptp_preservation | |
| wptp_step | Iris.ProgramLogic.wptp_step |
| Rocq Name | Status | Details |
|---|---|---|
| atomic_seq_wp_atomic | ||
| atomic_wp | ||
| atomic_wp_inv | ||
| atomic_wp_mask_weaken | ||
| atomic_wp_seq | ||
| atomic_wp_seq_step | ||
| persistent_seq_wp_atomic |
| Rocq Name | Status | Details |
|---|---|---|
| EctxLanguageMixin | ||
| ectxLanguage | ||
| ectx_lang | ||
| ectx_lang_mixin | ||
| Ectx_step' | Iris.ProgramLogic.BaseStep.ContextStep.ofBaseStep | |
| LanguageOfEctx | Iris.ProgramLogic.EctxLanguage.instLanguage | |
| base_atomic | Iris.ProgramLogic.EctxLanguage.BaseAtomic | |
| base_irreducible | Iris.ProgramLogic.BaseStep.Irreducible | |
| base_prim_fill_reducible | Iris.ProgramLogic.EctxLanguage.primStep_reducible_fill_of_baseStep_reducible | |
| base_prim_fill_reducible_no_obs | Iris.ProgramLogic.EctxLanguage.primStep_reducibleNoObs_fill_of_baseStep_reducibleNoObs | |
| base_prim_irreducible | Iris.ProgramLogic.EctxLanguage.baseStep_irreducible_of_primStep_irreducible | |
| base_prim_reducible | Iris.ProgramLogic.EctxLanguage.primStep_reducible_of_baseStep_reducible | |
| base_prim_reducible_no_obs | Iris.ProgramLogic.EctxLanguage.primStep_reducibleNoObs_of_baseStep_reducibleNoObs | |
| base_prim_step | Iris.ProgramLogic.EctxLanguage.primStep_of_baseStep | |
| base_redex_unique | Iris.ProgramLogic.EctxLanguage.base_redex_unique | |
| base_reducible | Iris.ProgramLogic.BaseStep.Reducible | |
| base_reducible_no_obs | Iris.ProgramLogic.BaseStep.ReducibleNoObs | |
| base_reducible_no_obs_reducible | Iris.ProgramLogic.BaseStep.reducible_of_reducibleNoObs | |
| base_reducible_prim_step | Iris.ProgramLogic.EctxLanguage.baseStep_of_primStep_of_baseStep_reducible | |
| base_reducible_prim_step_ctx | Iris.ProgramLogic.EctxLanguage.exists_baseStep_of_primStep_fill_of_redex_baseStep_reducible | |
| base_step_not_stuck | Iris.ProgramLogic.EctxLanguage.base_step_not_stuck | |
| base_stuck | Iris.ProgramLogic.BaseStep.Stuck | |
| base_stuck_stuck | Iris.ProgramLogic.EctxLanguage.primStep_stuck_of_baseStep_stuck | |
| ectx_lang_ctx | Iris.ProgramLogic.EctxLanguage.instContextFill | |
| ectx_language_atomic | Iris.ProgramLogic.EctxLanguage.Atomic.ofBaseAtomic | |
| fill_comp | Iris.ProgramLogic.EvContext.fill_comp | |
| fill_empty | Iris.ProgramLogic.EvContext.fill_empty | |
| fill_inj | Iris.ProgramLogic.EvContext.fill_inj | |
| fill_prim_step | Iris.ProgramLogic.EctxLanguage.fill_primStep | |
| fill_reducible | Iris.ProgramLogic.EctxLanguage.fill_reducible | |
| fill_reducible_no_obs | Iris.ProgramLogic.EctxLanguage.reducibleNoObs_fill | |
| fill_val | Iris.ProgramLogic.EctxLanguage.fill_val | |
| not_base_reducible | Iris.ProgramLogic.BaseStep.not_reducible_iff_irreducible | |
| prim_base_irreducible | Iris.ProgramLogic.EctxLanguage.primStep_irreducible_of_baseStep_irreducible | |
| prim_base_reducible | Iris.ProgramLogic.EctxLanguage.baseStep_reducible_of_primStep_reducible | |
| prim_step | Iris.ProgramLogic.BaseStep.ContextStep | |
| pure_base_step | Iris.ProgramLogic.EctxLanguage.PureBaseStep | |
| pure_base_step_pure_step | Iris.ProgramLogic.EctxLanguage.purePrimStep_of_pureBaseStep | |
| pure_exec_fill | Iris.ProgramLogic.EctxLanguage.pureExec_fill | |
| step_by_val | Iris.ProgramLogic.EctxLanguage.step_by_val | |
| sub_redexes_are_values | Iris.ProgramLogic.EctxLanguage.SubredexesAreValues | |
| val_base_stuck | Iris.ProgramLogic.EctxLanguage.val_stuck |
| Rocq Name | Status | Details |
|---|---|---|
| wp_lift_atomic_base_step | _private.Iris.ProgramLogic.EctxLifting.0.Iris.ProgramLogic.wp_lift_atomic_base_step | |
| wp_lift_atomic_base_step_fupd | _private.Iris.ProgramLogic.EctxLifting.0.Iris.ProgramLogic.wp_lift_atomic_base_step_fupd | |
| wp_lift_atomic_base_step_no_fork | _private.Iris.ProgramLogic.EctxLifting.0.Iris.ProgramLogic.wp_lift_atomic_base_step_no_fork | |
| wp_lift_atomic_base_step_no_fork_fupd | _private.Iris.ProgramLogic.EctxLifting.0.Iris.ProgramLogic.wp_lift_atomic_base_step_no_fork_fupd | |
| wp_lift_base_step | _private.Iris.ProgramLogic.EctxLifting.0.Iris.ProgramLogic.wp_lift_base_step | |
| wp_lift_base_step_fupd | _private.Iris.ProgramLogic.EctxLifting.0.Iris.ProgramLogic.wp_lift_base_step_fupd | |
| wp_lift_base_stuck | _private.Iris.ProgramLogic.EctxLifting.0.Iris.ProgramLogic.wp_lift_base_stuck | |
| wp_lift_pure_base_stuck | _private.Iris.ProgramLogic.EctxLifting.0.Iris.ProgramLogic.wp_lift_pure_base_stuck | |
| wp_lift_pure_det_base_step_no_fork | _private.Iris.ProgramLogic.EctxLifting.0.Iris.ProgramLogic.wp_lift_pure_det_base_step_no_fork | |
| wp_lift_pure_det_base_step_no_fork' | _private.Iris.ProgramLogic.EctxLifting.0.Iris.ProgramLogic.wp_lift_pure_det_base_step_no_fork' |
| Rocq Name | Status | Details |
|---|---|---|
| EctxiLanguageMixin | ||
| ectxiLanguage | ||
| ectxi_lang | ||
| ectxi_lang_ectx | ||
| ectxi_lang_ectx_mixin | ||
| EctxLanguageOfEctxi | Iris.ProgramLogic.EctxItemLanguage.instEctxLanguage | |
| base_ctx_step_val | Iris.ProgramLogic.EctxLanguage.base_ctx_step_val | |
| ectxi_lang_ctx_item | Iris.ProgramLogic.EctxItemLanguage.instEvContext | |
| ectxi_language_sub_redexes_are_values | Iris.ProgramLogic.EctxItemLanguage.subredexes_are_values | |
| fill | Iris.ProgramLogic.EvContext.fill | |
| fill_app | Iris.ProgramLogic.EctxItemLanguage.fill_append | |
| fill_item_inj | Iris.ProgramLogic.EctxItemLanguage.fillItem_inj | |
| fill_item_no_val_inj | Iris.ProgramLogic.EctxItemLanguage.fillItem_no_val_inj | |
| fill_item_val | Iris.ProgramLogic.EctxItemLanguage.fillItem | |
| fill_not_val | Iris.ProgramLogic.Language.Context.toVal_eq_none_fill |
| Rocq Name | Status | Details |
|---|---|---|
| AsVal | ||
| IntoVal | ||
| as_vals_of_val | ||
| cfg | ||
| erased_step_pure_step_tp | ||
| erased_steps_nsteps | ||
| exprO | ||
| language_ctx_id | ||
| stateO | ||
| valO | ||
| Atomic | Iris.ProgramLogic.Language.Atomic | |
| LanguageCtx | Iris.ProgramLogic.Language.Context | |
| LanguageMixin | This feature was implemented differently using typeclasses | |
| PureExec | Iris.ProgramLogic.Language.PureExec | |
| as_val_is_Some | Iris.ProgramLogic.Language.as_val_isSome | |
| atomicity | Iris.ProgramLogic.Language.Atomicity | |
| erased_step | Iris.ProgramLogic.Language.ErasedStep | |
| erased_step_Permutation | Iris.ProgramLogic.Language.perm_of_erasedStep | |
| irreducible | Iris.ProgramLogic.PrimStep.Irreducible | |
| irreducible_fill | Iris.ProgramLogic.Language.Context.irreducible_fill | |
| irreducible_fill_inv | Iris.ProgramLogic.Language.Context.irreducible_fill_inv | |
| language | This feature was implemented differently using typeclasses | |
| not_not_stuck | Iris.ProgramLogic.Language.not_not_suck | |
| not_reducible | Iris.ProgramLogic.Language.not_reducible_iff_irreducible | |
| not_stuck | Iris.ProgramLogic.PrimStep.NotStuck | |
| not_stuck_fill_inv | Iris.ProgramLogic.Language.Context.notStuck_fill_inv | |
| nsteps | Iris.ProgramLogic.Language.NSteps | |
| of_to_val | Iris.ProgramLogic.ToVal.coe_of_toVal_eq_some | |
| of_to_val_flip | Iris.ProgramLogic.ToVal.toVal_eq_iff_coe | |
| of_val_inj | Iris.ProgramLogic.ToVal.TovVal.ofVal_inj | |
| prim_step_not_stuck | Iris.ProgramLogic.Language.notStuck_of_primStep | |
| pure_exec_ctx | Iris.ProgramLogic.Language.pureExec_fill | |
| pure_step | Iris.ProgramLogic.Language.PurePrimStep | |
| pure_step_ctx | Iris.ProgramLogic.Language.purePrimStep_fill | |
| pure_step_nsteps_ctx | Iris.ProgramLogic.Language.iterate_purePrimStep_fill | |
| reducible | Iris.ProgramLogic.PrimStep.Reducible | |
| reducible_fill | Iris.ProgramLogic.Language.Context.reducible_fill | |
| reducible_fill_inv | Iris.ProgramLogic.Language.Context.reducible_fill_inv | |
| reducible_no_obs | Iris.ProgramLogic.PrimStep.ReducibleNoObs | |
| reducible_no_obs_fill | Iris.ProgramLogic.Language.Context.reducibleNoObs_fill | |
| reducible_no_obs_fill_inv | Iris.ProgramLogic.Language.Context.reducibleNoObs_fill_inv | |
| reducible_no_obs_reducible | Iris.ProgramLogic.Language.reducible_of_reducibleNoObs | |
| reducible_not_val | Iris.ProgramLogic.Language.toVal_none_of_reducible | |
| rtc_pure_step_ctx | Iris.ProgramLogic.Language.ReflTransGen_pureStep_fill | |
| rtc_pure_step_val | Iris.ProgramLogic.Language.ReflTransGen_purePrimStep_val | |
| step | Iris.ProgramLogic.Language.Step | |
| step_Permutation | Iris.ProgramLogic.Language.perm_of_step | |
| step_insert | Iris.ProgramLogic.Language.step_update_of_getElem? | |
| strongly_atomic_atomic | Iris.ProgramLogic.Language.stronglyAtomic_atomic | |
| stuck | Iris.ProgramLogic.PrimStep.Stuck | |
| stuck_fill | Iris.ProgramLogic.Language.Context.stuck_fill | |
| stuckness_to_atomicity | Iris.ProgramLogic.Language.Atomicity.ofStuckness | |
| to_of_val | Iris.ProgramLogic.ToVal.toVal_coe | |
| val_irreducible | Iris.ProgramLogic.Language.val_irreducible | |
| val_stuck | Iris.ProgramLogic.Language.val_stuck |
| Rocq Name | Status | Details |
|---|---|---|
| wp_lift_atomic_step | Iris.ProgramLogic.wp_lift_atomic_step | |
| wp_lift_atomic_step_fupd | Iris.ProgramLogic.wp_lift_atomic_step_fupd | |
| wp_lift_pure_det_step_no_fork | Iris.ProgramLogic.wp_lift_pure_det_step_no_fork | |
| wp_lift_pure_step_no_fork | Iris.ProgramLogic.wp_lift_pure_step_no_fork | |
| wp_lift_pure_stuck | Iris.ProgramLogic.wp_lift_pure_stuck | |
| wp_lift_step | Iris.ProgramLogic.wp_lift_step | |
| wp_lift_step_fupd | Iris.ProgramLogic.wp_lift_step_fupd | |
| wp_lift_step_fupdN | Iris.ProgramLogic.wp_lift_step_fupdN | |
| wp_lift_stuck | Iris.ProgramLogic.wp_lift_stuck | |
| wp_pure_step_fupd | Iris.ProgramLogic.wp_pure_step_fupd | |
| wp_pure_step_later | Iris.ProgramLogic.wp_pure_step_later |
| Rocq Name | Status | Details |
|---|---|---|
| ownP | ||
| ownPGS | ||
| ownPG_irisGS | ||
| ownPGpreS | ||
| ownP_adequacy | ||
| ownP_eq | ||
| ownP_invariance | ||
| ownP_lift_atomic_base_step | ||
| ownP_lift_atomic_det_base_step | ||
| ownP_lift_atomic_det_base_step_no_fork | ||
| ownP_lift_atomic_det_step | ||
| ownP_lift_atomic_det_step_no_fork | ||
| ownP_lift_atomic_step | ||
| ownP_lift_base_step | ||
| ownP_lift_base_stuck | ||
| ownP_lift_pure_base_step | ||
| ownP_lift_pure_det_base_step_no_fork | ||
| ownP_lift_pure_det_step_no_fork | ||
| ownP_lift_pure_step | ||
| ownP_lift_step | ||
| ownP_lift_stuck | ||
| ownP_state_twice | ||
| ownP_timeless | ||
| ownPΣ | ||
| reducible_not_val_inhabitant | ||
| subG_ownPΣ |
| Rocq Name | Status | Details |
|---|---|---|
| twp_total | ||
| twp_twptp | ||
| twptp | ||
| twptp_Permutation | ||
| twptp_app | ||
| twptp_ind | ||
| twptp_pre | ||
| twptp_pre_mono | ||
| twptp_pre_mono' | ||
| twptp_total | ||
| twptp_unfold |
| Rocq Name | Status | Details |
|---|---|---|
| twp_lift_atomic_base_step | ||
| twp_lift_atomic_base_step_no_fork | ||
| twp_lift_base_step | ||
| twp_lift_pure_base_step_no_fork | ||
| twp_lift_pure_det_base_step_no_fork |
| Rocq Name | Status | Details |
|---|---|---|
| twp_lift_atomic_step | ||
| twp_lift_pure_det_step_no_fork | ||
| twp_lift_pure_step_no_fork | ||
| twp_lift_step | ||
| twp_pure_step |
| Rocq Name | Status | Details |
|---|---|---|
| add_modal_fupd_twp | ||
| elim_acc_twp_atomic | ||
| elim_modal_bupd_twp | ||
| elim_modal_fupd_twp | ||
| elim_modal_fupd_twp_atomic | ||
| elim_modal_fupd_twp_atomic_wrong_mask | ||
| elim_modal_fupd_twp_wrong_mask | ||
| frame_twp | ||
| fupd_twp | ||
| twp' | ||
| twp_atomic | ||
| twp_aux | ||
| twp_bind | ||
| twp_bind_inv | ||
| twp_def | ||
| twp_frame_l | ||
| twp_frame_r | ||
| twp_frame_wand | ||
| twp_fupd | ||
| twp_ind | ||
| twp_mask_mono | ||
| twp_mono | ||
| twp_mono' | ||
| twp_ne | ||
| twp_pre | ||
| twp_pre' | ||
| twp_pre_mono | ||
| twp_pre_mono' | ||
| twp_proper | ||
| twp_strong_mono | ||
| twp_stuck_mono | ||
| twp_stuck_weaken | ||
| twp_unfold | ||
| twp_unseal | ||
| twp_value | ||
| twp_value' | ||
| twp_value_fupd | ||
| twp_value_fupd' | ||
| twp_wand | ||
| twp_wand_l | ||
| twp_wand_r | ||
| twp_wp | ||
| twp_wp_fupdN_strong | ||
| twp_wp_step |
| Rocq Name | Status | Details |
|---|---|---|
| add_modal_fupd_wp | ||
| elim_acc_wp_atomic | ||
| elim_acc_wp_nonatomic | ||
| elim_modal_bupd_wp | Iris.elimModalBupdWp | |
| elim_modal_fupd_wp | Iris.elimModalFupdWp | |
| elim_modal_fupd_wp_atomic | Iris.elimModalFupdWpAtomic | |
| elim_modal_fupd_wp_atomic_wrong_mask | Iris.elimModalFupdWpAtomic_wrongMask | |
| elim_modal_fupd_wp_wrong_mask | Iris.elimModalFupdWp_wrongMask | |
| frame_wp | Iris.frameWp | |
| fupd_wp | Iris.fupd_wp | |
| irisGS_gen | Iris.IrisGS_gen | |
| is_except_0_wp | Iris.isExcept0Wp | |
| wp' | We do not use Iris' custom seal/unseal visibility control | |
| wp_atomic | Iris.wp_atomic | |
| wp_aux | We do not use Iris' custom seal/unseal visibility control | |
| wp_bind | Iris.wp_bind | |
| wp_bind_inv | Iris.wp_bind_inv | |
| wp_contractive | Iris.wp_contractive | |
| wp_credit_access | Iris.wp_credit_access | |
| wp_def | Iris.wp.def | |
| wp_flip_mono' | No `Proper` typeclass in Lean | |
| wp_frame_l | Iris.wp_frame_l | |
| wp_frame_r | Iris.wp_frame_r | |
| wp_frame_step_l | Iris.wp_frame_step_l | |
| wp_frame_step_l' | Iris.wp_frame_step_l' | |
| wp_frame_step_r | Iris.wp_frame_step_r | |
| wp_frame_step_r' | Iris.wp_frame_step_r' | |
| wp_frame_wand | Iris.wp_frame_wand | |
| wp_fupd | Iris.wp_fupd | |
| wp_mask_mono | Iris.wp_mask_mono | |
| wp_mono | Iris.wp_mono | |
| wp_mono' | No `Proper` typeclass in Lean | |
| wp_ne | Iris.wp_ne | |
| wp_pre | Iris.wp.pre | |
| wp_pre_contractive | Iris.wp.pre.contractive | |
| wp_proper | Derivable using NonExpansive.eqv | |
| wp_step_fupd | Iris.wp_step_fupd | |
| wp_step_fupdN | Iris.wp_step_fupdN | |
| wp_step_fupdN_strong | Iris.wp_step_fupdN_strong | |
| wp_strong_mono | Iris.wp_strong_mono | |
| wp_stuck_mono | Iris.wp_stuck_mono | |
| wp_stuck_weaken | Iris.wp_stuck_weaken | |
| wp_unfold | Iris.wp_unfold | |
| wp_unseal | We do not use Iris' custom seal/unseal visibility control | |
| wp_value | Iris.wp_value | |
| wp_value' | Iris.wp_value' | |
| wp_value_fupd | Iris.wp_value_fupd | |
| wp_value_fupd' | Iris.wp_value_fupd' | |
| wp_wand | Iris.wp_wand | |
| wp_wand_l | Iris.wp_wand_l | |
| wp_wand_r | Iris.wp_wand_r |
▶
proofmode/828/1123 (74%)▶
Intro Patterns12/19 (63%)| Name | Status | Details |
|---|---|---|
| IAll (pattern: **) | ||
| IClear (pattern: {selpat}) | ||
| IClearFrame (pattern: {$selpat}) | ||
| IForall (pattern: *) | ||
| IPureIntro (pattern: !%) | ||
| IRewrite (pattern: ->/<-) | ||
| ISimpl (pattern: /=) | ||
| IDone (pattern: //) | pattern: // | |
| IDrop (pattern: _) | pattern: - | |
| IFrame (pattern: $) | pattern: $ | |
| IFresh (pattern: ?) | pattern: _ | |
| IIdent (pattern: H) | pattern: H | |
| IIntuitionistic (pattern: #H) | pattern: #H | |
| IList (pattern: [ ... ]) | pattern: ⟨ ... ⟩ | |
| IList (pattern: [ ... | ... ]) | pattern: ( ... | ... ) | |
| IModalElim (pattern: >H) | pattern: >H | |
| IModalIntro (pattern: !>) | pattern: !> | |
| IPure (pattern: %x) | pattern: %x | |
| ISpatial (pattern: -#H) | pattern: ∗H |
▶
Specialization Patterns8/13 (62%)| Name | Status | Details |
|---|---|---|
| Nested (pattern: (H spat ...)) | ||
| SAutoFrame (Kind: Intuitionistic) (pattern: [#$]) | pattern: [#$] | |
| SAutoFrame (Kind: Modal) (pattern: [>$]) | pattern: [>$] | |
| SGoal (Kind: Intuitionistic) (pattern: [#H1 ...]) | pattern: [#H1 ...] | |
| SGoal (Kind: Modal) (pattern: [>H1 ...]) | pattern: [>H1 ...] | |
| SAutoFrame (Kind: Spatial) (pattern: [$]) | pattern: [$] | |
| SGoal (Done) (pattern: [... //]) | pattern: [... //] | |
| SGoal (Frame) (pattern: [$H1]) | pattern: [$H1] | |
| SGoal (Hyps) (pattern: [H1 ...]) | pattern: [H1 ...] | |
| SGoal (Kind: Spatial) (pattern: [H1 ...]) | pattern: [H1 ...] | |
| SGoal (Negate) (pattern: [-H1 ...]) | pattern: [-H1 ...] | |
| SIdent (pattern: H) | pattern: H | |
| SPureGoal (pattern: [%]) | pattern: % |
▶
Tactics32/45 (71%)| Name | Status | Details |
|---|---|---|
| iAccu | ||
| iDestruct (all destruct patterns) | ||
| iEval | ||
| iFrame (existential quantifiers) | ||
| iInduction | ||
| iIntros (all intro patterns) | ||
| iInv | ||
| iNext (with later credits) | ||
| iPure (pure destructuring patterns) | (also for other tactics using ipure) | |
| iSimpl | ||
| iSpecialize (all specialization patterns) | ||
| iStartProof (with bi specified) | ||
| iUnfold | ||
| iApply | iapply | |
| iAssert | ihave _ : _ | |
| iAssumption | iassumption | |
| iAssumptionCoq | weird tactic | |
| iClear | iclear | |
| iCombine | icombine | |
| iDestruct (basic) | icases | |
| iEmpIntro | iempintro | |
| iExFalso | iexfalso | |
| iExact | iexact | |
| iExists | iexists | |
| iFrame (basic) | iframe | |
| iIntros (basic) | iintro | |
| iLeft | ileft | |
| iLöb | iloeb | |
| iMod | imod | |
| iModIntro | imodintro | |
| iNext (basic) | inext | |
| iPoseProof | ihave _ := _ | |
| iPure (basic) | ipure | |
| iPureIntro | ipureintro | |
| iRename | irename | |
| iRevert | irevert | |
| iRewrite | irewrite | |
| iRight | iright | |
| iSolveSideCondition | iSolveSideconditionAt | |
| iSpecialize (basic) | ispecialize | |
| iSpecialize (duplicate context for persistent conclusion) | ispecialize | |
| iSplit | isplit | |
| iStartProof (basic) | istart | |
| iStopProof | istop | |
| rules for trivial | itrivial |
| Rocq Name | Status | Details |
|---|---|---|
| Pos_succ | file ignored: Rocq-specific basic functionality | |
| ascii_beq | file ignored: Rocq-specific basic functionality | |
| ascii_beq_true | file ignored: Rocq-specific basic functionality | |
| beq | file ignored: Rocq-specific basic functionality | |
| beq_eq_dec | file ignored: Rocq-specific basic functionality | |
| beq_true | file ignored: Rocq-specific basic functionality | |
| direction | file ignored: Rocq-specific basic functionality | |
| ident.ident | file ignored: Rocq-specific basic functionality | |
| ident_beq | file ignored: Rocq-specific basic functionality | |
| ident_beq_reflect | file ignored: Rocq-specific basic functionality | |
| ident_beq_true | file ignored: Rocq-specific basic functionality | |
| lazy_andb_true | file ignored: Rocq-specific basic functionality | |
| maybe_IAnon | file ignored: Rocq-specific basic functionality | |
| maybe_INamed | file ignored: Rocq-specific basic functionality | |
| negb | file ignored: Rocq-specific basic functionality | |
| negb_true | file ignored: Rocq-specific basic functionality | |
| pm_app | file ignored: Rocq-specific basic functionality | |
| pm_from_option | file ignored: Rocq-specific basic functionality | |
| pm_option_bind | file ignored: Rocq-specific basic functionality | |
| pm_option_fun | file ignored: Rocq-specific basic functionality | |
| positive_beq | file ignored: Rocq-specific basic functionality | |
| positive_beq_true | file ignored: Rocq-specific basic functionality | |
| string_beq | file ignored: Rocq-specific basic functionality | |
| string_beq_reflect | file ignored: Rocq-specific basic functionality | |
| string_beq_true | file ignored: Rocq-specific basic functionality |
| Rocq Name | Status | Details |
|---|---|---|
| add_modal_forall | ||
| add_modal_tforall | ||
| add_modal_wand | ||
| add_modal_wandM | ||
| as_emp_valid_tforall | ||
| elim_inv_acc_with_close | ||
| elim_inv_acc_without_close | ||
| elim_modal_tforall | ||
| elim_modal_wandM | ||
| from_and_big_sepL2_app_persistent | ||
| from_and_big_sepL2_cons_persistent | ||
| from_and_big_sepL_app_persistent | ||
| from_and_big_sepL_cons_persistent | ||
| from_and_big_sepMS_disj_union_persistent | ||
| from_and_pure_iff | ||
| from_assumption_tforall | ||
| from_exist_exist | ||
| from_exist_texist | ||
| from_forall_tforall | ||
| from_pure_big_sepL | ||
| from_pure_big_sepM | ||
| from_pure_big_sepMS | ||
| from_pure_big_sepS | ||
| from_pure_texist | ||
| from_pure_tforall | ||
| from_sep_big_sepL2_app | ||
| from_sep_big_sepL2_cons | ||
| from_sep_big_sepL_app | ||
| from_sep_big_sepL_cons | ||
| from_sep_big_sepMS_disj_union | ||
| from_sep_pure_iff | ||
| from_tforall_pure | ||
| from_wand_wandM | ||
| into_exist_texist | ||
| into_forall_impl | ||
| into_forall_impl_pure | ||
| into_forall_tforall | ||
| into_forall_wand | ||
| into_pure_big_sepL | ||
| into_pure_big_sepM | ||
| into_pure_big_sepMS | ||
| into_pure_big_sepS | ||
| into_pure_forall | ||
| into_pure_pure_wand | ||
| into_pure_texist | ||
| into_pure_tforall | ||
| into_sep_big_sepL2_cons | ||
| into_sep_big_sepL_app | ||
| into_sep_big_sepL_cons | ||
| into_sep_big_sepMS_disj_union | ||
| into_wand_affine_args | ||
| into_wand_forall_prop_false | ||
| into_wand_forall_prop_true | ||
| into_wand_impl_false_false | ||
| into_wand_impl_false_true | ||
| into_wand_impl_true_false | ||
| into_wand_impl_true_true | ||
| into_wand_tforall | ||
| into_wand_wandM | ||
| AndIntoSep | Iris.ProofMode.AndIntoSep | |
| as_emp_valid_emp_valid | Iris.ProofMode.asEmpValidEmpValid | |
| as_emp_valid_entails | Iris.ProofMode.asEmpValid_entails | |
| as_emp_valid_equiv | Iris.ProofMode.asEmpValid_equiv | |
| as_emp_valid_forall | Iris.ProofMode.asEmpValid_forall | |
| combine_sep_as_absorbingly | Iris.ProofMode.combineSepGives_absorbingly | |
| combine_sep_as_affinely | Iris.ProofMode.combineSepGives_affinely | |
| combine_sep_as_intuitionistically | Iris.ProofMode.combineSepGives_intuitionistically | |
| combine_sep_as_persistently | Iris.ProofMode.combineSepGives_persistently | |
| elim_modal_absorbingly_here | Iris.ProofMode.elimModal_absorbingly_here | |
| elim_modal_forall | Iris.ProofMode.elimModal_forall | |
| elim_modal_wand | Iris.ProofMode.elimModal_wand | |
| from_affinely_affine | Iris.ProofMode.fromAffinely_affine | |
| from_affinely_default | Iris.ProofMode.fromAffinely_default | |
| from_affinely_intuitionistically | Iris.ProofMode.fromAffinely_intuitionistically | |
| from_and_and | Iris.ProofMode.fromAnd_and | |
| from_and_persistently | Iris.ProofMode.fromAnd_persistently | |
| from_and_persistently_sep | Iris.ProofMode.fromAnd_persistently_sep | |
| from_and_pure | Iris.ProofMode.fromAnd_pure | |
| from_and_sep_persistent_l | Iris.ProofMode.fromAnd_sep_persistent_l | |
| from_and_sep_persistent_r | Iris.ProofMode.fromAnd_sep_persistent_r | |
| from_assumption_absorbingly_r | Iris.ProofMode.fromAssumption_absorbingly_r | |
| from_assumption_affinely_l_true | Iris.ProofMode.fromAssumption_affinely_l | |
| from_assumption_affinely_r | Iris.ProofMode.fromAssumption_affinely_r | |
| from_assumption_exact | Iris.ProofMode.fromAssumption_exact | |
| from_assumption_forall | Iris.ProofMode.fromAssumption_forall | |
| from_assumption_intuitionistically_l | Iris.ProofMode.fromAssumption_intuitionistically_l | |
| from_assumption_intuitionistically_l_true | Iris.ProofMode.fromAssumption_intuitionistically_l_true | |
| from_assumption_intuitionistically_r | Iris.ProofMode.fromAssumption_intuitionistically_r | |
| from_assumption_persistently_l_false | Iris.ProofMode.fromAssumption_persistently_l_false | |
| from_assumption_persistently_l_true | Iris.ProofMode.fromAssumption_persistently_l_true | |
| from_assumption_persistently_r | Iris.ProofMode.fromAssumption_persistently_r | |
| from_exist_absorbingly | Iris.ProofMode.fromExists_absorbingly | |
| from_exist_affinely | Iris.ProofMode.fromExists_affinely | |
| from_exist_intuitionistically | Iris.ProofMode.fromExists_intuitionistically | |
| from_exist_persistently | Iris.ProofMode.fromExists_persistently | |
| from_exist_pure | Iris.ProofMode.fromExists_pure | |
| from_forall_forall | Iris.ProofMode.fromForall_forall | |
| from_forall_impl_pure | Iris.ProofMode.fromForall_imp_pure | |
| from_forall_intuitionistically | Iris.ProofMode.fromForall_intuitionistically | |
| from_forall_persistently | Iris.ProofMode.fromForall_persistently | |
| from_forall_pure | Iris.ProofMode.fromForall_pure | |
| from_forall_pure_not | Iris.ProofMode.fromForall_pure_not | |
| from_forall_wand_pure | Iris.ProofMode.fromForall_wand_pure | |
| from_impl_impl | Iris.ProofMode.fromImp_imp | |
| from_modal_absorbingly | Iris.ProofMode.fromModal_absorbingly | |
| from_modal_affinely | Iris.ProofMode.fromModal_affinely | |
| from_modal_intuitionistically | Iris.ProofMode.fromModal_intuitionistically | |
| from_modal_intuitionistically_affine_bi | Iris.ProofMode.fromModal_intuitionistically_affine_bi | |
| from_modal_persistently | Iris.ProofMode.fromModal_persistently | |
| from_or_absorbingly | Iris.ProofMode.fromOr_absorbingly | |
| from_or_affinely | Iris.ProofMode.fromOr_affinely | |
| from_or_intuitionistically | Iris.ProofMode.fromOr_intuitionistically | |
| from_or_or | Iris.ProofMode.fromOr_or | |
| from_or_persistently | Iris.ProofMode.fromOr_persistently | |
| from_or_pure | Iris.ProofMode.fromOr_pure | |
| from_pure_absorbingly | Iris.ProofMode.fromPure_absorbingly | |
| from_pure_affinely_true | Iris.ProofMode.fromPure_affinely_true | |
| from_pure_emp | Iris.ProofMode.fromPure_emp | |
| from_pure_exist | Iris.ProofMode.fromPure_exists | |
| from_pure_forall | Iris.ProofMode.fromPure_forall | |
| from_pure_intuitionistically_true | Iris.ProofMode.fromPure_intuitionistically_true | |
| from_pure_persistently | Iris.ProofMode.fromPure_persistently | |
| from_pure_pure | Iris.ProofMode.fromPure_pure | |
| from_pure_pure_and | Iris.ProofMode.fromPure_pure_and | |
| from_pure_pure_impl | Iris.ProofMode.fromPure_pure_imp | |
| from_pure_pure_or | Iris.ProofMode.fromPure_pure_or | |
| from_pure_pure_sep_true | Iris.ProofMode.fromPure_pure_sep_true | |
| from_pure_pure_wand | Iris.ProofMode.fromPure_pure_wand | |
| from_sep_absorbingly | Iris.ProofMode.fromSep_absorbingly | |
| from_sep_affinely | Iris.ProofMode.fromSep_affinely | |
| from_sep_and | Iris.ProofMode.fromSep_and | |
| from_sep_intuitionistically | Iris.ProofMode.fromSep_intuitionistically | |
| from_sep_persistently | Iris.ProofMode.fromSep_persistently | |
| from_sep_pure | Iris.ProofMode.fromSep_pure | |
| from_sep_sep | Iris.ProofMode.fromSep_sep | |
| from_wand_wand | Iris.ProofMode.fromWand_wand | |
| into_absorbingly_True | Iris.ProofMode.intoAbsorbingly_true | |
| into_absorbingly_absorbing | Iris.ProofMode.intoAbsorbingly_absorbing | |
| into_absorbingly_default | Iris.ProofMode.intoAbsorbingly_default | |
| into_absorbingly_intuitionistically | Iris.ProofMode.intoAbsorbingly_intuitionistically | |
| into_and_affinely | Iris.ProofMode.intoAnd_affinely | |
| into_and_and | Iris.ProofMode.intoAnd_and | |
| into_and_and_affine_l | Iris.ProofMode.intoAnd_and_affine_l | |
| into_and_and_affine_r | Iris.ProofMode.intoAnd_and_affine_r | |
| into_and_intuitionistically | Iris.ProofMode.intoAnd_intuitionistically | |
| into_and_persistently | Iris.ProofMode.intoAnd_persistently | |
| into_and_pure | Iris.ProofMode.intoAnd_pure | |
| into_and_sep | Iris.ProofMode.intoAnd_sep | |
| into_and_sep_affine | Iris.ProofMode.intoAnd_sep_affine | |
| into_exist_absorbingly | Iris.ProofMode.intoExists_absorbingly | |
| into_exist_affinely | Iris.ProofMode.intoExists_affinely | |
| into_exist_and_pure | Iris.ProofMode.intoExist_and_pure | |
| into_exist_exist | Iris.ProofMode.intoExists_exists | |
| into_exist_intuitionistically | Iris.ProofMode.intoExists_intuitionistically | |
| into_exist_persistently | Iris.ProofMode.intoExists_persistently | |
| into_exist_pure | Iris.ProofMode.intoExists_pure | |
| into_exist_sep_pure | Iris.ProofMode.intoExist_sep_pure | |
| into_forall_affinely | Iris.ProofMode.intoForall_affinely | |
| into_forall_forall | Iris.ProofMode.intoForall_forall | |
| into_forall_intuitionistically | Iris.ProofMode.intoForall_intuitionistically | |
| into_forall_persistently | Iris.ProofMode.intoForall_persistently | |
| into_forall_wand_pure | Iris.ProofMode.intoForall_wand_pure | |
| into_or_absorbingly | Iris.ProofMode.intoOr_absorbingly | |
| into_or_affinely | Iris.ProofMode.intoOr_affinely | |
| into_or_intuitionistically | Iris.ProofMode.intoOr_intuitionistically | |
| into_or_or | Iris.ProofMode.intoOr_or | |
| into_or_persistently | Iris.ProofMode.intoOr_persistently | |
| into_or_pure | Iris.ProofMode.intoOr_pure | |
| into_persistent_affinely | Iris.ProofMode.intoPersistently_affinely | |
| into_persistent_here | Iris.ProofMode.intoPersistently_self | |
| into_persistent_intuitionistically | Iris.ProofMode.intoPersistently_intuitionistically | |
| into_persistent_persistent | Iris.ProofMode.intoPersistently_persistent | |
| into_persistent_persistently | Iris.ProofMode.intoPersistently_persistently | |
| into_pure_absorbingly | Iris.ProofMode.intoPure_absorbingly | |
| into_pure_affinely | Iris.ProofMode.intoPure_affinely | |
| into_pure_exist | Iris.ProofMode.intoPure_exists | |
| into_pure_intuitionistically | Iris.ProofMode.intoPure_intuitionistically | |
| into_pure_persistently | Iris.ProofMode.intoPure_persistently | |
| into_pure_pure | Iris.ProofMode.intoPure_pure | |
| into_pure_pure_and | Iris.ProofMode.intoPure_pure_and | |
| into_pure_pure_impl | Iris.ProofMode.intoPure_pure_imp | |
| into_pure_pure_or | Iris.ProofMode.intoPure_pure_or | |
| into_pure_pure_sep | Iris.ProofMode.intoPure_pure_sep | |
| into_sep_affinely | Iris.ProofMode.intoSep_affinely | |
| into_sep_affinely_trim | Iris.ProofMode.intoSep_affinely_trim | |
| into_sep_and_persistent_l | Iris.ProofMode.intoSep_and_persistent_l | |
| into_sep_and_persistent_r | Iris.ProofMode.intoSep_and_persistent_r | |
| into_sep_intuitionistically | Iris.ProofMode.intoSep_intuitionistically | |
| into_sep_intuitionistically_affine | Iris.ProofMode.intoSep_intuitionistically_affine | |
| into_sep_persistently | Iris.ProofMode.intoSep_persistently | |
| into_sep_persistently_affine | Iris.ProofMode.intoSep_persistently_affine | |
| into_sep_pure | Iris.ProofMode.intoSep_pure | |
| into_sep_sep | Iris.ProofMode.intoSep_sep | |
| into_wand_affine | Iris.ProofMode.intoWand_affinely | |
| into_wand_and_l | Iris.ProofMode.intoWand_and_l | |
| into_wand_and_r | Iris.ProofMode.intoWand_and_r | |
| into_wand_forall | Iris.ProofMode.intoWand_forall | |
| into_wand_impl' | IntoWand' is not used in Lean | |
| into_wand_intuitionistically | Iris.ProofMode.intoWand_intuitionistically | |
| into_wand_persistently_false | Iris.ProofMode.intoWand_persistently_false | |
| into_wand_persistently_true | Iris.ProofMode.intoWand_persistently_true | |
| into_wand_wand | Iris.ProofMode.intoWand_wand | |
| into_wand_wand' | IntoWand' is not used in Lean | |
| into_wand_wandM' | IntoWand' is not used in Lean | |
| maybe_combine_sep_as_absorbingly | Iris.ProofMode.combineSepAs_absorbingly | |
| maybe_combine_sep_as_affinely | Iris.ProofMode.combineSepAs_affinely | |
| maybe_combine_sep_as_intuitionistically | Iris.ProofMode.combineSepAs_intuitionistically | |
| maybe_combine_sep_as_persistently | Iris.ProofMode.combineSepAs_persistently |
| Rocq Name | Status | Details |
|---|---|---|
| from_exist_internal_included | Iris.ProofMode.fromExists_internalCmraIncluded | |
| from_pure_internal_cmra_valid | Iris.ProofMode.fromPure_internalCmraValid | |
| from_pure_internal_included | Iris.ProofMode.fromPure_internalCmraIncluded | |
| into_exist_internal_included | Iris.ProofMode.intoExists_internalCmraIncluded | |
| into_pure_internal_cmra_valid | Iris.ProofMode.intoPure_internalCmraValid | |
| into_pure_internal_included | Iris.ProofMode.intoPure_internalCmraIncluded |
| Rocq Name | Status | Details |
|---|---|---|
| add_modal_embed_bupd_goal | ||
| add_modal_embed_fupd_goal | ||
| as_emp_valid_embed | ||
| combine_sep_gives_embed | ||
| elim_modal_embed_bupd_goal | ||
| elim_modal_embed_bupd_hyp | ||
| elim_modal_embed_fupd_goal | ||
| elim_modal_embed_fupd_hyp | ||
| from_and_embed | ||
| from_exist_embed | ||
| from_forall_embed | ||
| from_impl_embed | ||
| from_modal_affinely_embed | ||
| from_modal_embed | ||
| from_modal_id_embed | ||
| from_modal_intuitionistically_embed | ||
| from_modal_later_embed | ||
| from_modal_persistently_embed | ||
| from_modal_plainly_embed | ||
| from_or_embed | ||
| from_pure_embed | ||
| from_sep_embed | ||
| from_wand_embed | ||
| into_and_embed | ||
| into_embed_affinely | ||
| into_embed_embed | ||
| into_except_0_embed | ||
| into_exist_embed | ||
| into_forall_embed | ||
| into_internal_eq_embed | ||
| into_inv_embed | ||
| into_later_embed | ||
| into_or_embed | ||
| into_persistent_embed | ||
| into_pure_embed | ||
| into_sep_embed | ||
| into_wand_affine_embed_false | ||
| into_wand_affine_embed_true | ||
| into_wand_embed | ||
| is_except_0_embed | ||
| maybe_combine_sep_as_embed |
| Rocq Name | Status | Details |
|---|---|---|
| GatherEvarsEq | ||
| TCCbnTele | ||
| frame_big_sepL2_app | ||
| frame_big_sepL2_cons | ||
| frame_big_sepL_app | ||
| frame_big_sepL_cons | ||
| frame_big_sepMS_disj_union | ||
| frame_embed | ||
| frame_eq_embed | ||
| frame_exist | ||
| frame_exist_helper | ||
| frame_exist_no_instantiate | ||
| frame_pure_embed | ||
| frame_texist | ||
| frame_tforall | ||
| frame_absorbingly | Iris.ProofMode.frame_absorbingly | |
| frame_affinely | Iris.ProofMode.frame_affinely | |
| frame_affinely_here | Iris.ProofMode.frame_affinely_here | |
| frame_affinely_here_absorbing | Iris.ProofMode.frame_affinely_here_absorbing | |
| frame_and | Iris.ProofMode.frame_and | |
| frame_bupd | Iris.ProofMode.frame_bupd | |
| frame_except_0 | Iris.ProofMode.frame_except_0 | |
| frame_forall | Iris.ProofMode.frame_forall | |
| frame_fupd | Iris.ProofMode.frame_fupd | |
| frame_here | Iris.ProofMode.frame_here | |
| frame_here_absorbing | Iris.ProofMode.frame_here_absorbing | |
| frame_here_pure | Iris.ProofMode.frame_here_pure | |
| frame_here_pure_persistent | Iris.ProofMode.frame_here_pure_persistent | |
| frame_impl | Iris.ProofMode.frame_impl | |
| frame_impl_persistent | Iris.ProofMode.frame_impl_persistent | |
| frame_intuitionistically | Iris.ProofMode.frame_intuitionistically | |
| frame_later | Iris.ProofMode.frame_later | |
| frame_laterN | Iris.ProofMode.frame_laterN | |
| frame_or_persistent | Iris.ProofMode.frame_or | |
| frame_or_spatial | Iris.ProofMode.frame_or | |
| frame_persistently | Iris.ProofMode.frame_persistently | |
| frame_sep_l | Iris.ProofMode.frame_sep_l | |
| frame_sep_persistent_l | Iris.ProofMode.frame_sep_both | |
| frame_sep_r | Iris.ProofMode.frame_sep_r | |
| frame_wand | Iris.ProofMode.frame_wand |
| Rocq Name | Status | Details |
|---|---|---|
| from_modal_Next | Iris.ProofMode.fromModal_internalEq_next | |
| from_pure_internal_eq | Iris.ProofMode.fromPure_internalEq | |
| into_internal_eq_absorbingly | Iris.ProofMode.intoInternalEq_absorbingly | |
| into_internal_eq_affinely | Iris.ProofMode.intoInternalEq_affinely | |
| into_internal_eq_internal_eq | Iris.ProofMode.intoInternalEq_internalEq | |
| into_internal_eq_intuitionistically | Iris.ProofMode.intoInternalEq_intuitionistically | |
| into_internal_eq_persistently | Iris.ProofMode.intoInternalEq_persistently | |
| into_internal_eq_plainly | Iris.ProofMode.intoInternalEq_plainly | |
| into_laterN_Next | Iris.ProofMode.intoLaterN_internalEq_next | |
| into_pure_eq | Iris.ProofMode.intoPure_internalEq |
| Rocq Name | Status | Details |
|---|---|---|
| add_modal_except_0 | ||
| add_modal_except_0_later | ||
| add_modal_later | ||
| add_modal_later_except_0 | ||
| into_laterN_big_sepL | ||
| into_laterN_big_sepL2 | ||
| into_laterN_big_sepM | ||
| into_laterN_big_sepM2 | ||
| into_laterN_big_sepMS | ||
| into_laterN_big_sepS | ||
| into_laterN_laterN_bool | ||
| into_sep_affinely_later | ||
| elim_modal_timeless | Iris.ProofMode.elimModal_timeless | |
| from_and_except_0 | Iris.ProofMode.fromAnd_except0 | |
| from_and_later | Iris.ProofMode.fromAnd_later | |
| from_and_laterN | Iris.ProofMode.fromAnd_laterN | |
| from_assumption_except_0 | Iris.ProofMode.fromAssumption_except0 | |
| from_assumption_later | Iris.ProofMode.fromAssumption_later | |
| from_assumption_laterN | Iris.ProofMode.fromAssumption_laterN | |
| from_exist_except_0 | Iris.ProofMode.fromExists_except0 | |
| from_exist_later | Iris.ProofMode.fromExists_later | |
| from_exist_laterN | Iris.ProofMode.fromExists_laterN | |
| from_forall_except_0 | Iris.ProofMode.fromForall_except0 | |
| from_forall_later | Iris.ProofMode.fromForall_later | |
| from_forall_laterN | Iris.ProofMode.fromForall_laterN | |
| from_modal_except_0 | Iris.ProofMode.fromModal_except0 | |
| from_modal_later | Iris.ProofMode.fromModal_later | |
| from_modal_laterN | Iris.ProofMode.fromModal_laterN | |
| from_or_except_0 | Iris.ProofMode.fromOr_except0 | |
| from_or_later | Iris.ProofMode.fromOr_later | |
| from_or_laterN | Iris.ProofMode.fromOr_laterN | |
| from_pure_except_0 | Iris.ProofMode.fromPure_except0 | |
| from_pure_later | Iris.ProofMode.fromPure_later | |
| from_pure_laterN | Iris.ProofMode.fromPure_laterN | |
| from_sep_except_0 | Iris.ProofMode.fromSep_except0 | |
| from_sep_later | Iris.ProofMode.fromSep_later | |
| from_sep_laterN | Iris.ProofMode.fromSep_laterN | |
| into_and_except_0 | Iris.ProofMode.intoAnd_except0 | |
| into_and_later | Iris.ProofMode.intoAnd_later | |
| into_and_laterN | Iris.ProofMode.intoAnd_laterN | |
| into_except_0_absorbingly | Iris.ProofMode.intoExcept0_absorbingly | |
| into_except_0_affinely | Iris.ProofMode.intoExcept0_affinely | |
| into_except_0_except_0 | Iris.ProofMode.intoExcept0_except0 | |
| into_except_0_intuitionistically | Iris.ProofMode.intoExcept0_intuitionistically | |
| into_except_0_later | Iris.ProofMode.intoExcept0_later | |
| into_except_0_later_if | Iris.ProofMode.intoExcept0_laterIf | |
| into_except_0_persistently | Iris.ProofMode.intoExcept0_persistently | |
| into_exist_except_0 | Iris.ProofMode.intoExists_except0 | |
| into_exist_later | Iris.ProofMode.intoExists_later | |
| into_exist_laterN | Iris.ProofMode.intoExists_laterN | |
| into_forall_except_0 | Iris.ProofMode.intoForall_except0 | |
| into_forall_later | Iris.ProofMode.intoForall_later | |
| into_forall_laterN | Iris.ProofMode.intoForall_laterN | |
| into_laterN_0 | Iris.ProofMode.intoLaterN_default_0 | |
| into_laterN_and_l | Iris.ProofMode.intoLaterN_and | |
| into_laterN_and_r | Iris.ProofMode.intoLaterN_and | |
| into_laterN_exist | Iris.ProofMode.intoLaterN_exists | |
| into_laterN_forall | Iris.ProofMode.intoLaterN_forall | |
| into_laterN_later | Iris.ProofMode.intoLaterN_later | |
| into_laterN_laterN | Iris.ProofMode.intoLaterN_laterN | |
| into_laterN_or_l | Iris.ProofMode.intoLaterN_or | |
| into_laterN_or_r | Iris.ProofMode.intoLaterN_or | |
| into_laterN_sep_l | Iris.ProofMode.intoLaterN_sep | |
| into_laterN_sep_r | Iris.ProofMode.intoLaterN_sep | |
| into_later_absorbingly | Iris.ProofMode.intoLaterN_absorbingly | |
| into_later_affinely | Iris.ProofMode.intoLaterN_affinely | |
| into_later_intuitionistically | Iris.ProofMode.intoLaterN_intuitionistically | |
| into_later_persistently | Iris.ProofMode.intoLaterN_persistently | |
| into_or_except_0 | Iris.ProofMode.intoOr_except0 | |
| into_or_later | Iris.ProofMode.intoOr_later | |
| into_or_laterN | Iris.ProofMode.intoOr_laterN | |
| into_sep_except_0 | Iris.ProofMode.intoSep_except0 | |
| into_sep_later | Iris.ProofMode.intoSep_later | |
| into_sep_laterN | Iris.ProofMode.intoSep_laterN | |
| into_wand_later | Iris.ProofMode.intoWand_later | |
| into_wand_laterN | Iris.ProofMode.intoWand_laterN | |
| into_wand_laterN_args | IntoWand' is not used in Lean | |
| into_wand_later_args | IntoWand' is not used in Lean | |
| is_except_0_except_0 | Iris.ProofMode.isExcept0_except0 | |
| is_except_0_later | Iris.ProofMode.isExcept0_later | |
| maybe_combine_sep_as_except_0 | Iris.ProofMode.combineSepAs_except0 | |
| maybe_combine_sep_as_later | Iris.ProofMode.combineSepAs_later | |
| maybe_combine_sep_as_laterN | Iris.ProofMode.combineSepAs_laterN | |
| maybe_combine_sep_gives_except_0 | Iris.ProofMode.combineSepGives_except0 | |
| maybe_combine_sep_gives_later | Iris.ProofMode.combineSepGives_later | |
| maybe_combine_sep_gives_laterN | Iris.ProofMode.combineSepGives_laterN |
| Rocq Name | Status | Details |
|---|---|---|
| make_embed_default | ||
| make_embed_emp | ||
| make_embed_pure | ||
| False_quick_affine | Iris.ProofMode.quickAffine_False | |
| absorbingly_quick_absorbing | Iris.ProofMode.quickAbsorbing_absorbingly | |
| affinely_quick_affine | Iris.ProofMode.quickAffine_affinely | |
| bi_affine_quick_absorbing | Iris.ProofMode.quickAbsorbing_biAffine | |
| bi_affine_quick_affine | Iris.ProofMode.quickAffine_biAffine | |
| emp_quick_affine | Iris.ProofMode.quickAffine_emp | |
| intuitionistically_quick_affine | Iris.ProofMode.quickAffine_intuitionistically | |
| make_absorbingly_absorbing | Iris.ProofMode.makeAbsorbingly_absorbing | |
| make_absorbingly_default | Iris.ProofMode.makeAbsorbingly_default | |
| make_absorbingly_emp | Iris.ProofMode.makeAbsorbingly_emp | |
| make_affinely_True | Iris.ProofMode.makeAffinely_True | |
| make_affinely_affine | Iris.ProofMode.makeAffinely_affine | |
| make_affinely_default | Iris.ProofMode.makeAffinely_default | |
| make_and_default | Iris.ProofMode.makeAnd_default | |
| make_and_emp_l | Iris.ProofMode.makeAnd_emp_l | |
| make_and_emp_r | Iris.ProofMode.makeAnd_emp_r | |
| make_and_false_l | Iris.ProofMode.makeAnd_false_l | |
| make_and_false_r | Iris.ProofMode.makeAnd_false_r | |
| make_and_true_l | Iris.ProofMode.makeAnd_true_l | |
| make_and_true_r | Iris.ProofMode.makeAnd_true_r | |
| make_except_0_True | Iris.ProofMode.makeExcept0_True | |
| make_except_0_default | Iris.ProofMode.makeExcept0_default | |
| make_intuitionistically_True | Iris.ProofMode.makeIntuitionistically_True | |
| make_intuitionistically_True_affine | Iris.ProofMode.makeIntuitionistically_True_affine | |
| make_intuitionistically_default | Iris.ProofMode.makeIntuitionistically_default | |
| make_intuitionistically_emp | Iris.ProofMode.makeIntuitionistically_emp | |
| make_laterN_default | Iris.ProofMode.makeLaterN_default | |
| make_laterN_emp | Iris.ProofMode.makeLaterN_emp | |
| make_laterN_true | Iris.ProofMode.makeLaterN_True | |
| make_or_default | Iris.ProofMode.makeOr_default | |
| make_or_emp_l | Iris.ProofMode.makeOr_emp_l | |
| make_or_emp_r | Iris.ProofMode.makeOr_emp_r | |
| make_or_false_l | Iris.ProofMode.makeOr_false_l | |
| make_or_false_r | Iris.ProofMode.makeOr_false_r | |
| make_or_true_l | Iris.ProofMode.makeOr_true_l | |
| make_or_true_r | Iris.ProofMode.makeOr_true_r | |
| make_persistently_True | Iris.ProofMode.makePersistently_True | |
| make_persistently_default | Iris.ProofMode.makePersistently_default | |
| make_persistently_emp | Iris.ProofMode.makePersistently_emp | |
| make_sep_default | Iris.ProofMode.makeSep_default | |
| make_sep_emp_l | Iris.ProofMode.makeSep_emp_l | |
| make_sep_emp_r | Iris.ProofMode.makeSep_emp_r | |
| make_sep_true_l | Iris.ProofMode.makeSep_true_l | |
| make_sep_true_r | Iris.ProofMode.makeSep_true_r | |
| persistently_quick_absorbing | Iris.ProofMode.quickAbsorbing_persistently | |
| pure_quick_absorbing | Iris.ProofMode.quickAbsorbing_pure |
| Rocq Name | Status | Details |
|---|---|---|
| from_and_plainly | Iris.ProofMode.fromAnd_plainly | |
| from_assumption_plainly_l_false | Iris.ProofMode.fromAssumption_plainly_l_false | |
| from_assumption_plainly_l_true | Iris.ProofMode.fromAssumption_plainly_l_true | |
| from_exist_plainly | Iris.ProofMode.fromExists_plainly | |
| from_forall_plainly | Iris.ProofMode.fromForall_plainly | |
| from_modal_plainly | Iris.ProofMode.fromModal_plainly | |
| from_or_plainly | Iris.ProofMode.fromOr_plainly | |
| from_pure_plainly | Iris.ProofMode.fromPure_plainly | |
| from_sep_plainly | Iris.ProofMode.fromSep_plainly | |
| into_and_plainly | Iris.ProofMode.intoAnd_plainly | |
| into_except_0_plainly | Iris.ProofMode.intoExcept0_plainly | |
| into_exist_plainly | Iris.ProofMode.intoExists_plainly | |
| into_forall_plainly | Iris.ProofMode.intoForall_plainly | |
| into_later_plainly | Iris.ProofMode.intoLaterN_plainly | |
| into_or_plainly | Iris.ProofMode.intoOr_plainly | |
| into_pure_plainly | Iris.ProofMode.intoPure_plainly | |
| into_sep_plainly | Iris.ProofMode.intoSep_plainly | |
| into_sep_plainly_affine | Iris.ProofMode.intoSep_plainly_affine | |
| into_wand_plainly_false | Iris.ProofMode.intoWand_plainly_false | |
| into_wand_plainly_true | Iris.ProofMode.intoWand_plainly_true |
| Rocq Name | Status | Details |
|---|---|---|
| add_modal_bupd | ||
| add_modal_fupd | ||
| elim_acc_bupd | ||
| elim_acc_fupd | ||
| from_forall_fupd | ||
| from_forall_step_fupd | ||
| elim_modal_bupd | Iris.ProofMode.elimModal_bupd | |
| elim_modal_bupd_fupd | Iris.ProofMode.elimModal_bupd_fupd | |
| elim_modal_bupd_plain | Iris.ProofMode.elimModal_bupd_plain | |
| elim_modal_bupd_plain_goal | Iris.ProofMode.elimModal_bupd_plain_goal | |
| elim_modal_fupd_fupd | Iris.ProofMode.elimModal_fupd_fupd | |
| elim_modal_fupd_fupd_wrong_mask | Iris.ProofMode.elimModal_fupd_fupd_wrongMask | |
| from_assumption_bupd | Iris.ProofMode.fromAssumption_bupd | |
| from_assumption_fupd | Iris.ProofMode.fromAssumption_fupd | |
| from_exist_bupd | Iris.ProofMode.fromExists_bupd | |
| from_exist_fupd | Iris.ProofMode.fromExists_fupd | |
| from_modal_bupd | Iris.ProofMode.fromModal_bupd | |
| from_modal_fupd | Iris.ProofMode.fromModal_fupd | |
| from_modal_fupd_wrong_mask | Iris.ProofMode.fromModal_fupd_wrongMask | |
| from_or_bupd | Iris.ProofMode.fromOr_bupd | |
| from_or_fupd | Iris.ProofMode.fromOr_fupd | |
| from_pure_bupd | Iris.ProofMode.fromPure_bupd | |
| from_pure_fupd | Iris.ProofMode.fromPure_fupd | |
| from_sep_bupd | Iris.ProofMode.fromSep_bupd | |
| from_sep_fupd | Iris.ProofMode.fromSep_fupd | |
| into_and_bupd | Iris.ProofMode.intoAnd_bupd | |
| into_and_fupd | Iris.ProofMode.intoAnd_fupd | |
| into_forall_bupd | Iris.ProofMode.intoForall_bupd | |
| into_forall_fupd | Iris.ProofMode.intoForall_fupd | |
| into_wand_bupd | Iris.ProofMode.intoWand_bupd | |
| into_wand_bupd_args | IntoWand' is not used in Lean | |
| into_wand_bupd_persistent | Iris.ProofMode.intoWand_bupd_persistent | |
| into_wand_fupd | Iris.ProofMode.intoWand_fupd | |
| into_wand_fupd_args | IntoWand' is not used in Lean | |
| into_wand_fupd_persistent | Iris.ProofMode.intoWand_fupd_persistent | |
| is_except_0_bupd | Iris.ProofMode.isExcept0_bupd | |
| is_except_0_fupd | Iris.ProofMode.isExcept0_fupd |
| Rocq Name | Status | Details |
|---|---|---|
| AddModal | ||
| AsEmpValid0 | ||
| ElimAcc | ||
| ElimInv | ||
| FrameInstantiateExistDisabled | ||
| IntoAcc | ||
| IntoEmbed | ||
| IntoInv | ||
| IsApp | ||
| IsCons | ||
| IsDisjUnion | ||
| accessor | ||
| add_modal_id | ||
| is_app_app | ||
| is_cons_cons | ||
| is_disj_union_disj_union | ||
| AsEmpValid | Iris.ProofMode.AsEmpValid | |
| CombineSepAs | Iris.ProofMode.CombineSepAs | |
| CombineSepGives | Iris.ProofMode.CombineSepGives | |
| ElimModal | Iris.ProofMode.ElimModal | |
| Frame | Iris.ProofMode.Frame | |
| FromAffinely | Iris.ProofMode.FromAffinely | |
| FromAnd | Iris.ProofMode.FromAnd | |
| FromAssumption | Iris.ProofMode.FromAssumption | |
| FromExist | Iris.ProofMode.FromExists | |
| FromForall | Iris.ProofMode.FromForall | |
| FromImpl | Iris.ProofMode.FromImp | |
| FromModal | Iris.ProofMode.FromModal | |
| FromOr | Iris.ProofMode.FromOr | |
| FromPure | Iris.ProofMode.FromPure | |
| FromPureT | Iris.ProofMode.FromPure | |
| FromSep | Iris.ProofMode.FromSep | |
| FromWand | Iris.ProofMode.FromWand | |
| IntoAbsorbingly | Iris.ProofMode.IntoAbsorbingly | |
| IntoAnd | Iris.ProofMode.IntoAnd | |
| IntoExcept0 | Iris.ProofMode.IntoExcept0 | |
| IntoExist | Iris.ProofMode.IntoExists | |
| IntoForall | Iris.ProofMode.IntoForall | |
| IntoInternalEq | Iris.ProofMode.IntoInternalEq | |
| IntoLaterN | Iris.ProofMode.IntoLaterN | |
| IntoOr | Iris.ProofMode.IntoOr | |
| IntoPersistent | Iris.ProofMode.IntoPersistently | |
| IntoPure | Iris.ProofMode.IntoPure | |
| IntoPureT | Iris.ProofMode.IntoPure | |
| IntoSep | Iris.ProofMode.IntoSep | |
| IntoWand | Iris.ProofMode.IntoWand | |
| IntoWand' | not used in Lean | |
| IsExcept0 | Iris.ProofMode.IsExcept0 | |
| KnownLFromAssumption | Iris.ProofMode.FromAssumption | |
| KnownRFromAssumption | Iris.ProofMode.FromAssumption | |
| MaybeCombineSepAs | No need for progress_indicator | |
| MaybeFrame' | Iris.ProofMode.maybeFrame | |
| MaybeIntoLaterN | Iris.ProofMode.IntoLaterN | |
| as_emp_valid_1 | Iris.ProofMode.asEmpValid_1 | |
| as_emp_valid_2 | Iris.ProofMode.asEmpValid_2 | |
| as_emp_valid_direction | Iris.ProofMode.AsEmpValid.Direction | |
| elim_inv_tc_opaque | No tc_opaque in Lean | |
| elim_modal_tc_opaque | No tc_opaque in Lean | |
| from_and_tc_opaque | No tc_opaque in Lean | |
| from_exist_tc_opaque | No tc_opaque in Lean | |
| from_forall_tc_opaque | No tc_opaque in Lean | |
| from_modal_tc_opaque | No tc_opaque in Lean | |
| from_or_tc_opaque | No tc_opaque in Lean | |
| from_pureT_hint | FromPureT is not necessary in Lean | |
| from_pure_tc_opaque | No tc_opaque in Lean | |
| from_sep_tc_opaque | No tc_opaque in Lean | |
| from_wand_tc_opaque | No tc_opaque in Lean | |
| into_and_tc_opaque | No tc_opaque in Lean | |
| into_exist_tc_opaque | No tc_opaque in Lean | |
| into_forall_tc_opaque | No tc_opaque in Lean | |
| into_inv_tc_opaque | No tc_opaque in Lean | |
| into_or_tc_opaque | No tc_opaque in Lean | |
| into_pureT_hint | IntoPureT is not necessary in Lean | |
| into_pure_tc_opaque | No tc_opaque in Lean | |
| into_sep_tc_opaque | No tc_opaque in Lean | |
| into_wand_tc_opaque | No tc_opaque in Lean | |
| maybe_combine_sep_as_combine_sep_as | No longer required along with MaybeCombineSepAs | |
| maybe_combine_sep_as_default | Iris.ProofMode.combineSepAs_default | |
| maybe_frame_default | Iris.ProofMode.maybeFrame_default | |
| maybe_frame_default_persistent | Iris.ProofMode.maybeFrame_default_persistent | |
| maybe_frame_frame | Iris.ProofMode.maybeFrame | |
| maybe_into_laterN_default | Iris.ProofMode.intoLaterN_default | |
| maybe_into_laterN_default_0 | Iris.ProofMode.intoLaterN_default_0 | |
| pm_error | Iris.ProofMode.PMError | |
| progress_indicator | No longer required as it is only used by the type class MaybeCombineSepAs |
| Rocq Name | Status | Details |
|---|---|---|
| KnownMakeEmbed | ||
| MakeEmbed | ||
| KnownLMakeAnd | Iris.ProofMode.MakeAnd | |
| KnownLMakeOr | Iris.ProofMode.MakeOr | |
| KnownLMakeSep | Iris.ProofMode.MakeSep | |
| KnownMakeAbsorbingly | Iris.ProofMode.MakeAbsorbingly | |
| KnownMakeAffinely | Iris.ProofMode.MakeAffinely | |
| KnownMakeExcept0 | Iris.ProofMode.MakeExcept0 | |
| KnownMakeIntuitionistically | Iris.ProofMode.MakeIntuitionistically | |
| KnownMakeLaterN | Iris.ProofMode.MakeLaterN | |
| KnownMakePersistently | Iris.ProofMode.MakePersistently | |
| KnownRMakeAnd | Iris.ProofMode.MakeAnd | |
| KnownRMakeOr | Iris.ProofMode.MakeOr | |
| KnownRMakeSep | Iris.ProofMode.MakeSep | |
| MakeAbsorbingly | Iris.ProofMode.MakeAbsorbingly | |
| MakeAffinely | Iris.ProofMode.MakeAffinely | |
| MakeAnd | Iris.ProofMode.MakeAnd | |
| MakeExcept0 | Iris.ProofMode.MakeExcept0 | |
| MakeIntuitionistically | Iris.ProofMode.MakeIntuitionistically | |
| MakeLaterN | Iris.ProofMode.MakeLaterN | |
| MakeOr | Iris.ProofMode.MakeOr | |
| MakePersistently | Iris.ProofMode.MakePersistently | |
| MakeSep | Iris.ProofMode.MakeSep | |
| QuickAbsorbing | Iris.ProofMode.QuickAbsorbing | |
| QuickAffine | Iris.ProofMode.QuickAffine |
| Rocq Name | Status | Details |
|---|---|---|
| AffineEnv | file ignored: Tracked via the Tactics concept | |
| CombineSepsAs | file ignored: Tracked via the Tactics concept | |
| CombineSepsAsGives | file ignored: Tracked via the Tactics concept | |
| IntoEmpValid | file ignored: Tracked via the Tactics concept | |
| IntoIH | file ignored: Tracked via the Tactics concept | |
| IntoModalIntuitionisticEnv | file ignored: Tracked via the Tactics concept | |
| IntoModalSpatialEnv | file ignored: Tracked via the Tactics concept | |
| MaybeIntoLaterNEnvs | file ignored: Tracked via the Tactics concept | |
| TransformIntuitionisticEnv | file ignored: Tracked via the Tactics concept | |
| TransformSpatialEnv | file ignored: Tracked via the Tactics concept | |
| affine_env_bi | file ignored: Tracked via the Tactics concept | |
| affine_env_nil | file ignored: Tracked via the Tactics concept | |
| affine_env_snoc | file ignored: Tracked via the Tactics concept | |
| affine_env_spatial | file ignored: Tracked via the Tactics concept | |
| combine_seps_as_from_as_gives | file ignored: Tracked via the Tactics concept | |
| combine_seps_as_gives_nil | file ignored: Tracked via the Tactics concept | |
| combine_seps_as_gives_singleton | file ignored: Tracked via the Tactics concept | |
| combine_seps_gives_cons | file ignored: Tracked via the Tactics concept | |
| combine_seps_gives_of_envs | file ignored: Tracked via the Tactics concept | |
| into_emp_valid_forall | file ignored: Tracked via the Tactics concept | |
| into_emp_valid_here | file ignored: Tracked via the Tactics concept | |
| into_emp_valid_impl | file ignored: Tracked via the Tactics concept | |
| into_emp_valid_proj | file ignored: Tracked via the Tactics concept | |
| into_emp_valid_tforall | file ignored: Tracked via the Tactics concept | |
| into_ih_Forall | file ignored: Tracked via the Tactics concept | |
| into_ih_Forall2 | file ignored: Tracked via the Tactics concept | |
| into_ih_entails | file ignored: Tracked via the Tactics concept | |
| into_ih_forall | file ignored: Tracked via the Tactics concept | |
| into_ih_impl | file ignored: Tracked via the Tactics concept | |
| into_laterN_env_sound | file ignored: Tracked via the Tactics concept | |
| into_laterN_envs | file ignored: Tracked via the Tactics concept | |
| tac_accu | file ignored: Tracked via the Tactics concept | |
| tac_and_destruct | file ignored: Tracked via the Tactics concept | |
| tac_and_destruct_choice | file ignored: Tracked via the Tactics concept | |
| tac_and_split | file ignored: Tracked via the Tactics concept | |
| tac_apply | file ignored: Tracked via the Tactics concept | |
| tac_assert | file ignored: Tracked via the Tactics concept | |
| tac_assumption | file ignored: Tracked via the Tactics concept | |
| tac_assumption_coq | file ignored: Tracked via the Tactics concept | |
| tac_clear | file ignored: Tracked via the Tactics concept | |
| tac_combine_as | file ignored: Tracked via the Tactics concept | |
| tac_combine_as_gives | file ignored: Tracked via the Tactics concept | |
| tac_combine_gives | file ignored: Tracked via the Tactics concept | |
| tac_emp_intro | file ignored: Tracked via the Tactics concept | |
| tac_eval | file ignored: Tracked via the Tactics concept | |
| tac_eval_in | file ignored: Tracked via the Tactics concept | |
| tac_ex_falso | file ignored: Tracked via the Tactics concept | |
| tac_exist | file ignored: Tracked via the Tactics concept | |
| tac_exist_destruct | file ignored: Tracked via the Tactics concept | |
| tac_false_destruct | file ignored: Tracked via the Tactics concept | |
| tac_forall_intro | file ignored: Tracked via the Tactics concept | |
| tac_forall_revert | file ignored: Tracked via the Tactics concept | |
| tac_forall_specialize | file ignored: Tracked via the Tactics concept | |
| tac_frame | file ignored: Tracked via the Tactics concept | |
| tac_frame_pure | file ignored: Tracked via the Tactics concept | |
| tac_impl_intro | file ignored: Tracked via the Tactics concept | |
| tac_impl_intro_drop | file ignored: Tracked via the Tactics concept | |
| tac_impl_intro_intuitionistic | file ignored: Tracked via the Tactics concept | |
| tac_intuitionistic | file ignored: Tracked via the Tactics concept | |
| tac_inv_elim | file ignored: Tracked via the Tactics concept | |
| tac_löb | file ignored: Tracked via the Tactics concept | |
| tac_modal_elim | file ignored: Tracked via the Tactics concept | |
| tac_modal_intro | file ignored: Tracked via the Tactics concept | |
| tac_or_destruct | file ignored: Tracked via the Tactics concept | |
| tac_or_l | file ignored: Tracked via the Tactics concept | |
| tac_or_r | file ignored: Tracked via the Tactics concept | |
| tac_pose_proof | file ignored: Tracked via the Tactics concept | |
| tac_pose_proof_hyp | file ignored: Tracked via the Tactics concept | |
| tac_pure | file ignored: Tracked via the Tactics concept | |
| tac_pure_intro | file ignored: Tracked via the Tactics concept | |
| tac_pure_revert | file ignored: Tracked via the Tactics concept | |
| tac_rename | file ignored: Tracked via the Tactics concept | |
| tac_revert | file ignored: Tracked via the Tactics concept | |
| tac_revert_ih | file ignored: Tracked via the Tactics concept | |
| tac_rewrite | file ignored: Tracked via the Tactics concept | |
| tac_rewrite_in | file ignored: Tracked via the Tactics concept | |
| tac_sep_split | file ignored: Tracked via the Tactics concept | |
| tac_spatial | file ignored: Tracked via the Tactics concept | |
| tac_specialize | file ignored: Tracked via the Tactics concept | |
| tac_specialize_assert | file ignored: Tracked via the Tactics concept | |
| tac_specialize_assert_intuitionistic | file ignored: Tracked via the Tactics concept | |
| tac_specialize_assert_pure | file ignored: Tracked via the Tactics concept | |
| tac_specialize_frame | file ignored: Tracked via the Tactics concept | |
| tac_specialize_intuitionistic_helper | file ignored: Tracked via the Tactics concept | |
| tac_specialize_intuitionistic_helper_done | file ignored: Tracked via the Tactics concept | |
| tac_start | file ignored: Tracked via the Tactics concept | |
| tac_stop | file ignored: Tracked via the Tactics concept | |
| tac_unlock | file ignored: Tracked via the Tactics concept | |
| tac_unlock_True | file ignored: Tracked via the Tactics concept | |
| tac_unlock_emp | file ignored: Tracked via the Tactics concept | |
| tac_wand_intro | file ignored: Tracked via the Tactics concept | |
| tac_wand_intro_drop | file ignored: Tracked via the Tactics concept | |
| tac_wand_intro_intuitionistic | file ignored: Tracked via the Tactics concept | |
| transform_intuitionistic_env_nil | file ignored: Tracked via the Tactics concept | |
| transform_intuitionistic_env_snoc | file ignored: Tracked via the Tactics concept | |
| transform_intuitionistic_env_snoc_not | file ignored: Tracked via the Tactics concept | |
| transform_spatial_env_nil | file ignored: Tracked via the Tactics concept | |
| transform_spatial_env_snoc | file ignored: Tracked via the Tactics concept | |
| transform_spatial_env_snoc_not | file ignored: Tracked via the Tactics concept |
| Rocq Name | Status | Details |
|---|---|---|
| Envs_proper | file ignored: Implemented as Hyps in Expr.lean | |
| Esnoc_proper | file ignored: Implemented as Hyps in Expr.lean | |
| env | file ignored: Implemented as Hyps in Expr.lean | |
| env_Forall2 | file ignored: Implemented as Hyps in Expr.lean | |
| env_Forall2_antisymm | file ignored: Implemented as Hyps in Expr.lean | |
| env_Forall2_fresh | file ignored: Implemented as Hyps in Expr.lean | |
| env_Forall2_impl | file ignored: Implemented as Hyps in Expr.lean | |
| env_Forall2_refl | file ignored: Implemented as Hyps in Expr.lean | |
| env_Forall2_sym | file ignored: Implemented as Hyps in Expr.lean | |
| env_Forall2_trans | file ignored: Implemented as Hyps in Expr.lean | |
| env_Forall2_wf | file ignored: Implemented as Hyps in Expr.lean | |
| env_app | file ignored: Implemented as Hyps in Expr.lean | |
| env_app_disjoint | file ignored: Implemented as Hyps in Expr.lean | |
| env_app_fresh | file ignored: Implemented as Hyps in Expr.lean | |
| env_app_fresh_1 | file ignored: Implemented as Hyps in Expr.lean | |
| env_app_perm | file ignored: Implemented as Hyps in Expr.lean | |
| env_app_wf | file ignored: Implemented as Hyps in Expr.lean | |
| env_delete | file ignored: Implemented as Hyps in Expr.lean | |
| env_delete_fresh | file ignored: Implemented as Hyps in Expr.lean | |
| env_delete_wf | file ignored: Implemented as Hyps in Expr.lean | |
| env_dom | file ignored: Implemented as Hyps in Expr.lean | |
| env_intuitionistic_flip_mono | file ignored: Implemented as Hyps in Expr.lean | |
| env_intuitionistic_mono | file ignored: Implemented as Hyps in Expr.lean | |
| env_intuitionistic_proper | file ignored: Implemented as Hyps in Expr.lean | |
| env_lookup | file ignored: Implemented as Hyps in Expr.lean | |
| env_lookup_delete | file ignored: Implemented as Hyps in Expr.lean | |
| env_lookup_delete_Some | file ignored: Implemented as Hyps in Expr.lean | |
| env_lookup_delete_correct | file ignored: Implemented as Hyps in Expr.lean | |
| env_lookup_env_delete | file ignored: Implemented as Hyps in Expr.lean | |
| env_lookup_env_delete_ne | file ignored: Implemented as Hyps in Expr.lean | |
| env_lookup_perm | file ignored: Implemented as Hyps in Expr.lean | |
| env_lookup_snoc | file ignored: Implemented as Hyps in Expr.lean | |
| env_lookup_snoc_ne | file ignored: Implemented as Hyps in Expr.lean | |
| env_replace | file ignored: Implemented as Hyps in Expr.lean | |
| env_replace_fresh | file ignored: Implemented as Hyps in Expr.lean | |
| env_replace_lookup | file ignored: Implemented as Hyps in Expr.lean | |
| env_replace_perm | file ignored: Implemented as Hyps in Expr.lean | |
| env_replace_wf | file ignored: Implemented as Hyps in Expr.lean | |
| env_spatial_flip_mono | file ignored: Implemented as Hyps in Expr.lean | |
| env_spatial_is_nil | file ignored: Implemented as Hyps in Expr.lean | |
| env_spatial_is_nil_intuitionistically | file ignored: Implemented as Hyps in Expr.lean | |
| env_spatial_mono | file ignored: Implemented as Hyps in Expr.lean | |
| env_spatial_proper | file ignored: Implemented as Hyps in Expr.lean | |
| env_subenv | file ignored: Implemented as Hyps in Expr.lean | |
| env_subenv_fresh | file ignored: Implemented as Hyps in Expr.lean | |
| env_subenv_wf | file ignored: Implemented as Hyps in Expr.lean | |
| env_to_list | file ignored: Implemented as Hyps in Expr.lean | |
| env_to_list_proper | file ignored: Implemented as Hyps in Expr.lean | |
| env_to_list_subenv_proper | file ignored: Implemented as Hyps in Expr.lean | |
| env_to_prop | file ignored: Implemented as Hyps in Expr.lean | |
| env_to_prop_and | file ignored: Implemented as Hyps in Expr.lean | |
| env_to_prop_and_go | file ignored: Implemented as Hyps in Expr.lean | |
| env_to_prop_and_pers_sound | file ignored: Implemented as Hyps in Expr.lean | |
| env_to_prop_go | file ignored: Implemented as Hyps in Expr.lean | |
| env_to_prop_sound | file ignored: Implemented as Hyps in Expr.lean | |
| env_wf | file ignored: Implemented as Hyps in Expr.lean | |
| envs | file ignored: Implemented as Hyps in Expr.lean | |
| envs_Forall2 | file ignored: Implemented as Hyps in Expr.lean | |
| envs_Forall2_antisymm | file ignored: Implemented as Hyps in Expr.lean | |
| envs_Forall2_impl | file ignored: Implemented as Hyps in Expr.lean | |
| envs_Forall2_refl | file ignored: Implemented as Hyps in Expr.lean | |
| envs_Forall2_sym | file ignored: Implemented as Hyps in Expr.lean | |
| envs_Forall2_trans | file ignored: Implemented as Hyps in Expr.lean | |
| envs_app | file ignored: Implemented as Hyps in Expr.lean | |
| envs_app_singleton_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_app_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_clear_intuitionistic | file ignored: Implemented as Hyps in Expr.lean | |
| envs_clear_intuitionistic_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_clear_spatial | file ignored: Implemented as Hyps in Expr.lean | |
| envs_clear_spatial_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_delete | file ignored: Implemented as Hyps in Expr.lean | |
| envs_delete_intuitionistic | file ignored: Implemented as Hyps in Expr.lean | |
| envs_delete_spatial | file ignored: Implemented as Hyps in Expr.lean | |
| envs_dom | file ignored: Implemented as Hyps in Expr.lean | |
| envs_entails | file ignored: Implemented as Hyps in Expr.lean | |
| envs_entails_flip_mono | file ignored: Implemented as Hyps in Expr.lean | |
| envs_entails_mono | file ignored: Implemented as Hyps in Expr.lean | |
| envs_entails_proper | file ignored: Implemented as Hyps in Expr.lean | |
| envs_entails_unseal | file ignored: Implemented as Hyps in Expr.lean | |
| envs_incr_counter | file ignored: Implemented as Hyps in Expr.lean | |
| envs_incr_counter_equiv | file ignored: Implemented as Hyps in Expr.lean | |
| envs_incr_counter_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_delete | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_delete_Some | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_delete_list | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_delete_list_cons | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_delete_list_nil | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_delete_list_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_delete_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_envs_clear_spatial | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_envs_delete | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_envs_delete_ne | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_intuitionistic_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_snoc | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_snoc_ne | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_sound' | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_sound_2 | file ignored: Implemented as Hyps in Expr.lean | |
| envs_lookup_split | file ignored: Implemented as Hyps in Expr.lean | |
| envs_replace | file ignored: Implemented as Hyps in Expr.lean | |
| envs_replace_singleton_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_replace_singleton_sound' | file ignored: Implemented as Hyps in Expr.lean | |
| envs_replace_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_replace_sound' | file ignored: Implemented as Hyps in Expr.lean | |
| envs_simple_replace | file ignored: Implemented as Hyps in Expr.lean | |
| envs_simple_replace_maybe_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_simple_replace_singleton_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_simple_replace_singleton_sound' | file ignored: Implemented as Hyps in Expr.lean | |
| envs_simple_replace_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_simple_replace_sound' | file ignored: Implemented as Hyps in Expr.lean | |
| envs_snoc | file ignored: Implemented as Hyps in Expr.lean | |
| envs_snoc_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_split | file ignored: Implemented as Hyps in Expr.lean | |
| envs_split_go | file ignored: Implemented as Hyps in Expr.lean | |
| envs_split_go_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_split_sound | file ignored: Implemented as Hyps in Expr.lean | |
| envs_wf | file ignored: Implemented as Hyps in Expr.lean | |
| envs_wf' | file ignored: Implemented as Hyps in Expr.lean | |
| of_envs | file ignored: Implemented as Hyps in Expr.lean | |
| of_envs' | file ignored: Implemented as Hyps in Expr.lean | |
| of_envs'_alt | file ignored: Implemented as Hyps in Expr.lean | |
| of_envs_alt | file ignored: Implemented as Hyps in Expr.lean | |
| of_envs_eq | file ignored: Implemented as Hyps in Expr.lean | |
| of_envs_mono | file ignored: Implemented as Hyps in Expr.lean | |
| of_envs_mono' | file ignored: Implemented as Hyps in Expr.lean | |
| of_envs_proper | file ignored: Implemented as Hyps in Expr.lean | |
| of_envs_proper' | file ignored: Implemented as Hyps in Expr.lean | |
| pre_envs_entails | file ignored: Implemented as Hyps in Expr.lean | |
| pre_envs_entails_aux | file ignored: Implemented as Hyps in Expr.lean | |
| pre_envs_entails_def | file ignored: Implemented as Hyps in Expr.lean | |
| pre_envs_entails_unseal | file ignored: Implemented as Hyps in Expr.lean |
| Rocq Name | Status | Details |
|---|---|---|
| AsIdentName | file ignored: Rocq-specific ident name handling | |
| ident_name | file ignored: Rocq-specific ident name handling |
| Rocq Name | Status | Details |
|---|---|---|
| gallina_ident | Not necessary in Lean | |
| intro_pat | Iris.ProofMode.IntroPat | |
| intro_pat.big_conj | Not necessary in Lean | |
| intro_pat.close | Not necessary in Lean | |
| intro_pat.close_conj_list | Not necessary in Lean | |
| intro_pat.close_list | Not necessary in Lean | |
| intro_pat.parse | Not necessary in Lean | |
| intro_pat.parse_go | Not necessary in Lean | |
| intro_pat.stack_item | Not necessary in Lean | |
| intro_pat_intuitionistic | Iris.ProofMode.iCasesPat.should_try_dup_context |
| Rocq Name | Status | Details |
|---|---|---|
| esel_pat | Iris.ProofMode.SelTarget | |
| iTrm | Iris.ProofMode.PMTerm | |
| use_tac_specialize_intuitionistic_helper | Iris.ProofMode.iCasesPat.should_try_dup_context |
| Rocq Name | Status | Details |
|---|---|---|
| modality_flip_mono' | ||
| modality_mono' | ||
| modality_proper | ||
| modality | Iris.ProofMode.Modality | |
| modality_action | Iris.ProofMode.ModalityAction | |
| modality_and_forall | Handled by simplifying action_spec | |
| modality_and_transform | Handled by simplifying action_spec | |
| modality_emp | Iris.ProofMode.Modality | |
| modality_id | Iris.ProofMode.modality_id | |
| modality_id_mixin | Iris.ProofMode.modality_id | |
| modality_intuitionistic_action_spec | Iris.ProofMode.ModalityAction.action_spec | |
| modality_intuitionistic_forall | Handled by simplifying action_spec | |
| modality_intuitionistic_forall_big_and | Not necessary due to different env representation | |
| modality_intuitionistic_id | Handled by simplifying action_spec | |
| modality_intuitionistic_id_big_and | Not necessary due to different env representation | |
| modality_intuitionistic_transform | Handled by simplifying action_spec | |
| modality_mixin | Iris.ProofMode.Modality | |
| modality_mono | Iris.ProofMode.Modality | |
| modality_sep | Iris.ProofMode.Modality | |
| modality_spatial_action_spec | Iris.ProofMode.ModalityAction.action_spec | |
| modality_spatial_clear | Handled by simplifying action_spec | |
| modality_spatial_forall | Handled by simplifying action_spec | |
| modality_spatial_forall_big_sep | Not necessary due to different env representation | |
| modality_spatial_id | Handled by simplifying action_spec | |
| modality_spatial_transform | Handled by simplifying action_spec |
| Rocq Name | Status | Details |
|---|---|---|
| modality_embed | ||
| modality_embed_mixin | ||
| modality_affinely | Iris.ProofMode.modality_affinely | |
| modality_affinely_mixin | Iris.ProofMode.modality_affinely | |
| modality_intuitionistically | Iris.ProofMode.modality_intuitionistically | |
| modality_intuitionistically_mixin | Iris.ProofMode.modality_intuitionistically | |
| modality_laterN | Iris.ProofMode.modality_laterN | |
| modality_laterN_mixin | Iris.ProofMode.modality_laterN | |
| modality_persistently | Iris.ProofMode.modality_persistently | |
| modality_persistently_mixin | Iris.ProofMode.modality_persistently | |
| modality_plainly | Iris.ProofMode.modality_plainly | |
| modality_plainly_mixin | Iris.ProofMode.modality_plainly |
| Rocq Name | Status | Details |
|---|---|---|
| FrameMonPredAt | ||
| IsBiIndexRel | ||
| MakeMonPredAt | ||
| add_modal_at_bupd_goal | ||
| add_modal_at_fupd_goal | ||
| as_emp_valid_monPred_at | ||
| as_emp_valid_monPred_at_equiv | ||
| as_emp_valid_monPred_at_wand | ||
| elim_acc_at_None | ||
| elim_acc_at_Some | ||
| elim_inv_embed_with_close | ||
| elim_inv_embed_without_close | ||
| elim_modal_at | ||
| elim_modal_at_bupd_goal | ||
| elim_modal_at_bupd_hyp | ||
| elim_modal_at_fupd_goal | ||
| elim_modal_at_fupd_hyp | ||
| frame_monPred_at_absorbingly | ||
| frame_monPred_at_affinely | ||
| frame_monPred_at_and | ||
| frame_monPred_at_bupd | ||
| frame_monPred_at_embed | ||
| frame_monPred_at_enter | ||
| frame_monPred_at_exist | ||
| frame_monPred_at_forall | ||
| frame_monPred_at_fupd | ||
| frame_monPred_at_here | ||
| frame_monPred_at_impl | ||
| frame_monPred_at_intuitionistically | ||
| frame_monPred_at_later | ||
| frame_monPred_at_laterN | ||
| frame_monPred_at_objectively | ||
| frame_monPred_at_or | ||
| frame_monPred_at_persistently | ||
| frame_monPred_at_sep | ||
| frame_monPred_at_subjectively | ||
| frame_monPred_at_wand | ||
| from_and_monPred_at | ||
| from_assumption_make_monPred_at_l | ||
| from_assumption_make_monPred_at_r | ||
| from_assumption_make_monPred_objectively | ||
| from_assumption_make_monPred_subjectively | ||
| from_exist_monPred_at | ||
| from_exist_monPred_at_ex | ||
| from_forall_monPred_at | ||
| from_forall_monPred_at_impl | ||
| from_forall_monPred_at_objectively | ||
| from_forall_monPred_at_plainly | ||
| from_forall_monPred_at_wand | ||
| from_later_monPred_at | ||
| from_modal_affinely_monPred_at | ||
| from_modal_id_monPred_at | ||
| from_modal_intuitionistically_monPred_at | ||
| from_modal_objectively | ||
| from_modal_persistently_monPred_at | ||
| from_modal_subjectively | ||
| from_or_monPred_at | ||
| from_pure_monPred_at | ||
| from_pure_monPred_in | ||
| from_sep_monPred_at | ||
| into_and_monPred_at | ||
| into_embed_objective | ||
| into_except_0_monPred_at_bwd | ||
| into_except_0_monPred_at_fwd | ||
| into_exist_monPred_at | ||
| into_exist_monPred_at_ex | ||
| into_forall_monPred_at | ||
| into_forall_monPred_at_index | ||
| into_forall_monPred_at_objectively | ||
| into_forall_monPred_at_plainly | ||
| into_internal_eq_monPred_at | ||
| into_or_monPred_at | ||
| into_persistent_monPred_at | ||
| into_pure_monPred_at | ||
| into_pure_monPred_in | ||
| into_sep_monPred_at | ||
| into_wand_impl'_monPred | ||
| into_wand_monPred_at_known_unknown_ge | ||
| into_wand_monPred_at_known_unknown_le | ||
| into_wand_monPred_at_unknown_known | ||
| into_wand_monPred_at_unknown_unknown | ||
| into_wand_wand'_monPred | ||
| is_bi_index_rel_refl | ||
| is_except_0_monPred_at | ||
| make_monPred_at_absorbingly | ||
| make_monPred_at_absorbingly_if | ||
| make_monPred_at_affinely | ||
| make_monPred_at_affinely_if | ||
| make_monPred_at_and | ||
| make_monPred_at_bupd | ||
| make_monPred_at_default | ||
| make_monPred_at_embed | ||
| make_monPred_at_emp | ||
| make_monPred_at_except_0 | ||
| make_monPred_at_exists | ||
| make_monPred_at_forall | ||
| make_monPred_at_fupd | ||
| make_monPred_at_in | ||
| make_monPred_at_internal_eq | ||
| make_monPred_at_intuitionistically | ||
| make_monPred_at_intuitionistically_if | ||
| make_monPred_at_later | ||
| make_monPred_at_laterN | ||
| make_monPred_at_or | ||
| make_monPred_at_persistently | ||
| make_monPred_at_persistently_if | ||
| make_monPred_at_pure | ||
| make_monPred_at_sep | ||
| maybe_into_later_monPred_at | ||
| modality_objectively | ||
| modality_objectively_mixin |
| Rocq Name | Status | Details |
|---|---|---|
| sel_pat | Iris.ProofMode.SelPat | |
| sel_pat.parse | Iris.ProofMode.SelPat.parseOne | |
| sel_pat.parse_go | Not necessary in Lean | |
| sel_pat_pure | Not necessary in Lean |
| Rocq Name | Status | Details |
|---|---|---|
| goal_kind | Iris.ProofMode.SpecGoalKind | |
| goal_kind_modal | Iris.ProofMode.SpecGoalKind.isModal | |
| spec_goal | Iris.ProofMode.SpecGoal | |
| spec_pat | Iris.ProofMode.SpecPat | |
| spec_pat.close | Not necessary in Lean | |
| spec_pat.close_ident | Not necessary in Lean | |
| spec_pat.parse | Iris.ProofMode.SpecPat.parse | |
| spec_pat.parse_go | Not necessary in Lean | |
| spec_pat.stack_item | Not necessary in Lean | |
| spec_pat_modal | Iris.ProofMode.SpecPat.isModal |
| Rocq Name | Status | Details |
|---|---|---|
| StringToIdent.coq_string_to_list_byte | file ignored: Rocq-specific string-based ident handling |
| Rocq Name | Status | Details |
|---|---|---|
| cons_state | file ignored: Rocq-specific tokenizer | |
| state | file ignored: Rocq-specific tokenizer | |
| token | Iris.token | |
| tokenize | file ignored: Rocq-specific tokenizer | |
| tokenize_go | file ignored: Rocq-specific tokenizer |
▶
si_logic/88/123 (72%)| Rocq Name | Status | Details |
|---|---|---|
| siProp_plainly | ||
| siProp.siProp_and_unseal | Not needed in Lean. | |
| siProp.siProp_cmra_valid_unseal | Not needed in Lean. | |
| siProp.siProp_emp_unseal | Not needed in Lean. | |
| siProp.siProp_exist_unseal | Not needed in Lean. | |
| siProp.siProp_forall_unseal | Not needed in Lean. | |
| siProp.siProp_impl_unseal | Not needed in Lean. | |
| siProp.siProp_internal_eq_unseal | Not needed in Lean. | |
| siProp.siProp_later_unseal | Not needed in Lean. | |
| siProp.siProp_or_unseal | Not needed in Lean. | |
| siProp.siProp_persistently_unseal | Not needed in Lean. | |
| siProp.siProp_pure_unseal | Not needed in Lean. | |
| siProp.siProp_sep_unseal | Not needed in Lean. | |
| siProp.siProp_unseal | Not needed in Lean. | |
| siProp.siProp_wand_unseal | Not needed in Lean. | |
| siPropI | Iris.SiProp.instBI | |
| siProp_affine | Iris.SiProp.instBIAffine | |
| siProp_bi_later_mixin | Not needed in Lean. | |
| siProp_bi_mixin | Not needed in Lean. | |
| siProp_bi_persistently_mixin | Not needed in Lean. | |
| siProp_emp | Included in BIBase instance. | |
| siProp_later_contractive | Iris.SiProp.instBILaterContractive | |
| siProp_persistent | Iris.SiProp.instPersistent | |
| siProp_persistently | Included in BIBase instance. | |
| siProp_pure_forall | BiPureForall is not ported. | |
| siProp_sep | Included in BIBase instance. | |
| siProp_wand | Included in BIBase instance. |
| Rocq Name | Status | Details |
|---|---|---|
| siPropO | ||
| siProp_dist | ||
| siProp_dist' | ||
| siProp_equiv | ||
| siProp_equiv' | ||
| siProp_primitive.and_elim_l | ||
| siProp_primitive.and_elim_r | ||
| siProp_primitive.and_intro | ||
| siProp_primitive.and_ne | ||
| siProp_primitive.entails_anti_symm | ||
| siProp_primitive.entails_po | ||
| siProp_primitive.equiv_entails | ||
| siProp_primitive.exist_elim | ||
| siProp_primitive.exist_intro | ||
| siProp_primitive.exist_ne | ||
| siProp_primitive.forall_elim | ||
| siProp_primitive.forall_intro | ||
| siProp_primitive.forall_ne | ||
| siProp_primitive.impl_elim_l' | ||
| siProp_primitive.impl_intro_r | ||
| siProp_primitive.impl_ne | ||
| siProp_primitive.later_contractive | ||
| siProp_primitive.later_exist_false | ||
| siProp_primitive.later_false_em | ||
| siProp_primitive.later_forall_2 | ||
| siProp_primitive.later_intro | ||
| siProp_primitive.later_mono | ||
| siProp_primitive.or_elim | ||
| siProp_primitive.or_intro_l | ||
| siProp_primitive.or_intro_r | ||
| siProp_primitive.or_ne | ||
| siProp_primitive.pure_elim' | ||
| siProp_primitive.pure_forall_2 | ||
| siProp_primitive.pure_intro | ||
| SiProp_downclose | Iris.SiProp.downClose | |
| siProp | Iris.SiProp | |
| siProp_and | Iris.SiProp.and | |
| siProp_and_aux | Not needed in Lean. | |
| siProp_and_def | Not needed in Lean. | |
| siProp_and_unseal | Not needed in Lean. | |
| siProp_cmra_valid | Iris.SiProp.cmraValid | |
| siProp_cmra_valid_aux | Not needed in Lean. | |
| siProp_cmra_valid_def | Not needed in Lean. | |
| siProp_cmra_valid_unseal | Not needed in Lean. | |
| siProp_cofe | Iris.SiProp.instIsCOFE | |
| siProp_compl | Included in IsCOFE instance. | |
| siProp_entails | Iris.SiProp.entails | |
| siProp_exist | Iris.SiProp.exist | |
| siProp_exist_aux | Not needed in Lean. | |
| siProp_exist_def | Not needed in Lean. | |
| siProp_exist_unseal | Not needed in Lean. | |
| siProp_forall | Iris.SiProp.all | |
| siProp_forall_aux | Not needed in Lean. | |
| siProp_forall_def | Not needed in Lean. | |
| siProp_forall_unseal | Not needed in Lean. | |
| siProp_impl | Iris.SiProp.imp | |
| siProp_impl_aux | Not needed in Lean. | |
| siProp_impl_def | Not needed in Lean. | |
| siProp_impl_unseal | Not needed in Lean. | |
| siProp_internal_eq | Iris.SiProp.internalEq | |
| siProp_internal_eq_aux | Not needed in Lean. | |
| siProp_internal_eq_def | Not needed in Lean. | |
| siProp_internal_eq_unseal | Not needed in Lean. | |
| siProp_later | Iris.SiProp.later | |
| siProp_later_aux | Not needed in Lean. | |
| siProp_later_def | Not needed in Lean. | |
| siProp_later_unseal | Not needed in Lean. | |
| siProp_ofe_mixin | Not needed in Lean. | |
| siProp_or | Iris.SiProp.or | |
| siProp_or_aux | Not needed in Lean. | |
| siProp_or_def | Not needed in Lean. | |
| siProp_or_unseal | Not needed in Lean. | |
| siProp_primitive.cmra_valid_elim | Iris.SiProp.cmraValid_elim | |
| siProp_primitive.cmra_valid_intro | Iris.SiProp.cmraValid_intro | |
| siProp_primitive.cmra_valid_ne | Iris.SiProp.instNonExpansiveCmraValid | |
| siProp_primitive.cmra_valid_weaken | Iris.SiProp.cmraValid_weaken | |
| siProp_primitive.discrete_eq_1 | Iris.SiProp.discrete_eq_internalEq | |
| siProp_primitive.fun_extI | Iris.SiProp.fun_ext_internalEq | |
| siProp_primitive.internal_eq_entails | Iris.SiProp.internalEq_entails | |
| siProp_primitive.internal_eq_ne | Iris.SiProp.instNonExpansive₂InternalEq | |
| siProp_primitive.internal_eq_refl | Iris.SiProp.internalEq_refl | |
| siProp_primitive.internal_eq_rewrite | Iris.SiProp.internalEq_rewrite | |
| siProp_primitive.internal_eq_soundness | Iris.SiProp.internalEq_soundness | |
| siProp_primitive.later_equivI_1 | Iris.SiProp.later_equiv_internalEq_mp | |
| siProp_primitive.later_equivI_2 | Iris.SiProp.later_equiv_internalEq_mpr | |
| siProp_primitive.later_soundness | Iris.SiProp.later_soundness | |
| siProp_primitive.prop_ext_2 | Iris.SiProp.prop_ext | |
| siProp_primitive.pure_ne | Iris.SiProp.pure_dist_of_iff | |
| siProp_primitive.pure_soundness | Iris.SiProp.pure_soundness | |
| siProp_primitive.siProp_unseal | Not needed in Lean. | |
| siProp_primitive.sig_equivI_1 | Iris.SiProp.sig_equiv_internalEq | |
| siProp_primitive.valid_entails | Iris.SiProp.cmraValid_entails_iff | |
| siProp_pure | Iris.SiProp.pure | |
| siProp_pure_aux | Not needed in Lean. | |
| siProp_pure_def | Not needed in Lean. | |
| siProp_pure_unseal | Not needed in Lean. |