Proof Assistant Projects
Collection
Digesting proof assistant libraries for AI ingestion. • 84 items • Updated • 3
Datasets:
fact stringlengths 4 2k | type stringclasses 20
values | library stringclasses 8
values | imports listlengths 0 41 | filename stringlengths 11 62 | symbolic_name stringlengths 1 69 | docstring stringclasses 1
value |
|---|---|---|---|---|---|---|
disj_conj_distribR : "(A \<and> B \<or> C) = ((A \<or> C) \<and> (B \<or> C))" apply (rule iffI) apply (rule conjI) apply fast apply fast apply auto done text \<open>The statement of Hoare triple lemmas are generally indented in the following way.\<close> | lemma | docs | [] | docs/Style.thy | disj_conj_distribR | |
my_hoare_triple_lemma : "\<lbrace>precondition_one and precondition_two and precondition three\<rbrace> my_function param_a param_b \<lbrace>post_condition\<rbrace>" oops text \<open> or \<close> | lemma | docs | [] | docs/Style.thy | my_hoare_triple_lemma | |
my_hoare_triple_lemma : "\<lbrace>precondition_one and precondition_two and precondition three\<rbrace> my_function param_a param_b \<lbrace>post_condition\<rbrace>" oops text \<open> Definitions, record and datatypes are generally indented as follows and generally use @{text \<open>\<equiv>\<close>} rather than @{text... | lemma | docs | [] | docs/Style.thy | my_hoare_triple_lemma | |
word_bits :: nat where "word_bits \<equiv> 32" | definition | docs | [] | docs/Style.thy | word_bits | |
long_defn_type :: "'this => 'is => 'a => 'long => 'type => 'that => 'does => 'not => 'fit => 'in => 'one => 'line" where "long_defn_type \<equiv> undefined" | definition | docs | [] | docs/Style.thy | long_defn_type | |
foo_fun :: "nat \<Rightarrow> nat" where "foo_fun 0 = 0" | "foo_fun (Suc n) = n" | fun | docs | [] | docs/Style.thy | foo_fun | |
cdl_cnode = cdl_cnode_caps :: type_foo cdl_cnode_size_bits :: type_bar | record | docs | [] | docs/Style.thy | cdl_cnode | |
cdl_object = Endpoint | Tcb type_foo | CNode cdl_cnode | Untyped | datatype | docs | [] | docs/Style.thy | cdl_object | |
cdl_arch = IA32 | ARM11 text \<open> There are tools to automatically indent proofs in jEdit. In terms of rules: * definition and fun should be on the same line as the name. * Everything after the first line of a definition or fun statement should be indented. * Type definitions (record, type_synonym, datatype) have th... | datatype | docs | [] | docs/Style.thy | cdl_arch | |
hd_opt :: "'a list \<Rightarrow> 'a option" where "hd_opt \<equiv> case_list None (\<lambda>h t. Some h)" | definition | docs | [] | docs/Style.thy | hd_opt | |
hd_opt4 :: "'a list \<Rightarrow> 'a option" where "hd_opt4 \<equiv> case_list None (\<lambda>h t. Some h)" text \<open> If an apply line causes an overflow of the 100 char line limit, use one of the following two patterns: aligning on ":" or aligning on left.\<close> | definition | docs | [] | docs/Style.thy | hd_opt4 | |
test_lemma0 : "\<lbrakk>hd_opt l \<noteq> None; hd_opt (hd l) = Some x\<rbrakk> \<Longrightarrow> hd_opt (concat l) = Some x" apply (clarsimp simp: hd_opt_def split: list.splits) done | lemma | docs | [] | docs/Style.thy | test_lemma0 | |
test_lemma1 : "\<lbrakk>hd_opt l \<noteq> None; hd_opt (hd l) = Some x\<rbrakk> \<Longrightarrow> hd_opt (concat l) = Some x" apply (clarsimp simp: hd_opt_def split: list.splits) done | lemma | docs | [] | docs/Style.thy | test_lemma1 | |
test_lemma3 : "case_option None hd_opt (hd_opt l) = Some x \<Longrightarrow> hd_opt (concat l) = Some x" apply ((cases l; simp add: hd_opt_def), rename_tac h t, case_tac h; simp) done | lemma | docs | [] | docs/Style.thy | test_lemma3 | |
shows "\<lbrakk> A; B; C\<rbrakk> \<Longrightarrow> D" \<comment> \<open>right-wrapping OK\<close> and "\<lbrakk> A; B; C\<rbrakk> \<Longrightarrow> D" \<comment> \<open>left-wrapping OK\<close> oops \<comment> \<open>mixing styles: NOT OK\<close> text \<open> Some operators and syntax only have ONE style. As seen in o... | lemma | docs | [] | docs/Style.thy | shows | |
shows "\<lbrakk> A ; B \<rbrakk> \<comment> \<open>wrong: always on right\<close> \<comment> \<open>ok: \<Longrightarrow> can be either left or right\<close> \<Longrightarrow> C" and \<comment> \<open>wrong: `shows/and` only on left!\<close> "D" and "E" \<comment> \<open>ok: on left\<close> proof - have "True \<and> Tr... | lemma | docs | [] | docs/Style.thy | shows | |
conjI3 : "\<lbrakk>a; b; c\<rbrakk> \<Longrightarrow> a \<and> b \<and> c" by simp text \<open> For left operator-wrapping style, use this version. It was chosen based on being space-optimising and nice-looking (variable instantiations and rule all left-align, while operators right-align):\<close> | lemma | docs | [] | docs/Style.thy | conjI3 | |
some_f :: "nat \<Rightarrow> nat" where "some_f x \<equiv> case x of 0 \<Rightarrow> 1 | Suc n \<Rightarrow> n+2" lemmas some_f_simps[simp] = some_f_def[split_simps nat.split] (* Pattern is simplified automatically: *) | definition | docs | [] | docs/Style.thy | some_f | |
long_running_ending : "True \<and> True \<and> True \<and> True \<and> True \<and> True \<and> True" apply (intro conjI) apply blast apply blast by auto \<comment> \<open>only if long-running, and note indentation!\<close> | lemma | docs | [] | docs/Style.thy | long_running_ending | |
my_hoare_triple_lemma : "\<lbrace>precondition_one and precondition_two and precondition three\<rbrace> my_function param_a param_b \<lbrace>post_condition\<rbrace>" unfolding my_function_def oops text \<open>instead of\<close> | lemma | docs | [] | docs/Style.thy | my_hoare_triple_lemma | |
my_hoare_triple_lemma : "\<lbrace>precondition_one and precondition_two and precondition three\<rbrace> my_function param_a param_b \<lbrace>post_condition\<rbrace>" apply (clarsimp simp: my_function_def) oops | lemma | docs | [] | docs/Style.thy | my_hoare_triple_lemma | |
ccorres_example : "ccorres rrel xf P Q hs a c" oops text \<open> where rrel is the return relation, xf is the extraction function, P is the abstract guard, Q is the concrete guard, hs is the handler stack, a is the abstract function, and c is the concrete function. If the statement can fit on a single line within the c... | lemma | docs | [] | docs/Style.thy | ccorres_example | |
short_ccorres_example : "ccorres rrel xf short_abs_guard short_conc_guard hs short_abs_fn short_conc_fn" oops | lemma | docs | [] | docs/Style.thy | short_ccorres_example | |
long_ccorres_example : "ccorres rrel xf long_abs_guard long_conc_guard hs long_abs_fn long_conc_fn" oops | lemma | docs | [] | docs/Style.thy | long_ccorres_example | |
longer_ccorres_example : "ccorres long_rrel long_xf long_abs_guard long_conc_guard hs long_abs_fn long_conc_fn" oops text \<open> The concrete guard will often be simply @{term UNIV}, or an intersection of terms of the form @{term "\<lbrace>\<acute>pointer = cond\<rbrace>"}, which supersedes the set-builder notation wh... | lemma | docs | [] | docs/Style.thy | longer_ccorres_example | |
valid :: "'a \<Rightarrow> 'b \<Rightarrow> 'c \<Rightarrow> bool" ("\<lbrace>_\<rbrace>/ _ /\<lbrace>_\<rbrace>") where "\<lbrace>P\<rbrace> f \<lbrace>Q\<rbrace> \<equiv> undefined" | definition | docs | [] | docs/Style_pre.thy | valid | |
pred_conj :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool)" (infixl "and" 35) where "pred_conj P Q \<equiv> \<lambda>x. P x \<and> Q x" consts my_function :: 'a | definition | docs | [] | docs/Style_pre.thy | pred_conj | |
where my_function_def: "my_function \<equiv> undefined" | axiomatization | docs | [] | docs/Style_pre.thy | where | |
ccorres :: "'a \<Rightarrow> 'b \<Rightarrow> 'c \<Rightarrow> 'd \<Rightarrow> 'e \<Rightarrow> 'f \<Rightarrow> 'g \<Rightarrow> bool" where "ccorres rrel xf P Q hs a c \<equiv> undefined" | definition | docs | [] | docs/Style_pre.thy | ccorres | |
c_guard :: "'h \<Rightarrow> 'i \<Rightarrow> 'd" ("\<lbrace> _ = _ \<rbrace>") where "\<lbrace> ptr = cond \<rbrace> \<equiv> undefined" | definition | docs | [] | docs/Style_pre.thy | c_guard | |
ptr_select :: "'h \<Rightarrow> 'h" ("\<acute>") where "ptr_select \<equiv> undefined" | definition | docs | [] | docs/Style_pre.thy | ptr_select | |
mk_var_app nm (f $ _) = let val (_, xs) = strip_comb f val n = length xs val T = domain_type (fastype_of f) in mk_var_app nm f $ Free (nm ^ string_of_int n, T) end | mk_var_app _ t = t | fun | lib | [
"Main",
"keywords",
"\"add_upd_simps\"",
"::",
"thy_decl"
] | lib/AddUpdSimps.thy | mk_var_app | |
get_upd_apps (f $ (g $ x)) = if is_Const (head_of f) andalso is_Const (head_of g) andalso domain_type (fastype_of g) = range_type (fastype_of g) then mk_var_app "x" f $ (mk_var_app "y" (g $ x)) :: get_upd_apps f @ get_upd_apps (g $ x) else get_upd_apps f @ get_upd_apps (g $ x) | get_upd_apps (f $ x) = get_upd_apps f @ ... | fun | lib | [
"Main",
"keywords",
"\"add_upd_simps\"",
"::",
"thy_decl"
] | lib/AddUpdSimps.thy | get_upd_apps | |
mk_upd_simps ctxt upd_app (simps, done, n) = let val n = n + 1 val _ = n <= 5000 orelse raise TERM ("mk_upd_simps: 5000", [upd_app]) val (nm, _) = dest_Const (head_of upd_app) val def = Proof_Context.get_thm ctxt (nm ^ "_def") val rhs = case (mk_var_app "x" upd_app, upd_app) of (f $ _, _ $ (_ $ x)) => f $ x | _ => rais... | fun | lib | [
"Main",
"keywords",
"\"add_upd_simps\"",
"::",
"thy_decl"
] | lib/AddUpdSimps.thy | mk_upd_simps | |
mk_upd_simps_tm ctxt t = let val uas = get_upd_apps t |> sort_distinct Term_Ord.fast_term_ord val (simps, _, _) = fold (mk_upd_simps ctxt) uas ([], Termtab.empty, 0) in simps end | fun | lib | [
"Main",
"keywords",
"\"add_upd_simps\"",
"::",
"thy_decl"
] | lib/AddUpdSimps.thy | mk_upd_simps_tm | |
add_upd_simps t exsimps ctxt = let val thms = mk_upd_simps_tm (ctxt addsimps exsimps) t val _ = map (Thm.pretty_thm ctxt #> Pretty.writeln) thms in if null thms then ctxt else (Local_Theory.notes [((@{binding upd_simps}, []), [(thms, [])])] ctxt |> #2) addsimps thms | fun | lib | [
"Main",
"keywords",
"\"add_upd_simps\"",
"::",
"thy_decl"
] | lib/AddUpdSimps.thy | add_upd_simps | |
s_bcorres_underlying where "s_bcorres_underlying t f g s \<equiv> (\<lambda>(x,y). (x, t y)) ` (fst (f s)) \<subseteq> (fst (g (t s)))" | definition | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | s_bcorres_underlying | |
bcorres_underlying where "bcorres_underlying t f g \<equiv> \<forall>s. s_bcorres_underlying t f g s" | definition | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | bcorres_underlying | |
wpc_helper_bcorres : "bcorres_underlying t f g \<Longrightarrow> wpc_helper P Q (bcorres_underlying t f g)" by (simp add: wpc_helper_def split: prod.split) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | wpc_helper_bcorres | |
wpc_helper_s_bcorres : "s_bcorres_underlying t f g s \<Longrightarrow> wpc_helper P Q (s_bcorres_underlying t f g s)" by (simp add: wpc_helper_def split: prod.split) wpc_setup "\<lambda>f. bcorres_underlying t f g" wpc_helper_bcorres wpc_setup "\<lambda>f. s_bcorres_underlying t f g s" wpc_helper_bcorres | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | wpc_helper_s_bcorres | |
s_bcorres_underlying_split [wp_split]: "(\<And>r s'. (r,s') \<in> fst (f s) \<Longrightarrow> (s_bcorres_underlying t (g r) (g' r) s')) \<Longrightarrow> s_bcorres_underlying t f f' s \<Longrightarrow> s_bcorres_underlying t (f >>= g) (f' >>= g') s" by (clarsimp simp: s_bcorres_underlying_def bind_def) force | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | s_bcorres_underlying_split | |
bcorres_underlying_split [wp_split]: "(\<And>r. (bcorres_underlying t (g r) (g' r))) \<Longrightarrow> bcorres_underlying t f f' \<Longrightarrow> bcorres_underlying t (f >>= g) (f' >>= g')" by (simp add: bcorres_underlying_def s_bcorres_underlying_split) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | bcorres_underlying_split | |
get_s_bcorres_underlying [wp]: "s_bcorres_underlying t (f s) (f' (t s)) s \<Longrightarrow> s_bcorres_underlying t (get >>= f) (get >>= f') s" by (simp add: gets_def s_bcorres_underlying_def get_def bind_def return_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | get_s_bcorres_underlying | |
get_bcorres [wp]: "(\<And>x. bcorres_underlying t (f x) (f' (t x))) \<Longrightarrow> bcorres_underlying t (get >>= f) (get >>= f')" by (simp add: bcorres_underlying_def get_s_bcorres_underlying) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | get_bcorres | |
gets_s_bcorres_underlying [wp]: "x' (t s) = x s \<Longrightarrow> s_bcorres_underlying t (gets x) (gets x') s" by (simp add: s_bcorres_underlying_def gets_def get_def bind_def return_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | gets_s_bcorres_underlying | |
gets_bcorres_underlying [wp]: "(\<And>s. x' (t s) = x s) \<Longrightarrow> bcorres_underlying t (gets x) (gets x')" by (simp add: bcorres_underlying_def gets_s_bcorres_underlying) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | gets_bcorres_underlying | |
gets_map_bcorres_underlying [wp]: "(\<And>s. f' (t s) p = f s p) \<Longrightarrow> bcorres_underlying t (gets_map f p) (gets_map f' p)" by (simp add: gets_map_def bcorres_underlying_def s_bcorres_underlying_def simpler_gets_def bind_def assert_opt_def fail_def return_def split: option.splits) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | gets_map_bcorres_underlying | |
gets_bcorres_underlying ': "(\<And>xa. bcorres_underlying t (f (x xa)) (f' (x' (t xa)))) \<Longrightarrow> bcorres_underlying t (gets x >>= f) (gets x' >>= f')" by (wpsimp simp: gets_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | gets_bcorres_underlying | |
assert_bcorres_underlying [wp]: "f = f' \<Longrightarrow> bcorres_underlying t (assert f) (assert f')" by (simp add: assert_def bcorres_underlying_def return_def s_bcorres_underlying_def fail_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | assert_bcorres_underlying | |
return_bcorres [wp]: "bcorres_underlying t (return x) (return x)" by (simp add:return_def bcorres_underlying_def s_bcorres_underlying_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | return_bcorres | |
drop_sbcorres_underlying : "bcorres_underlying t f g \<Longrightarrow> s_bcorres_underlying t f g s" by (simp add: bcorres_underlying_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | drop_sbcorres_underlying | |
use_sbcorres_underlying : "(\<And>s. s_bcorres_underlying t f g s) \<Longrightarrow> bcorres_underlying t f g" by (simp add: bcorres_underlying_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | use_sbcorres_underlying | |
bcorres_underlying_throwError [wp]: "bcorres_underlying t (throwError a) (throwError a)" by (wpsimp simp: throwError_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | bcorres_underlying_throwError | |
s_bcorres_underlying_splitE [wp_split]: "(\<And>r s'. (Inr r,s') \<in> fst (f s) \<Longrightarrow> s_bcorres_underlying t (g r) (g' r) s') \<Longrightarrow> s_bcorres_underlying t f f' s \<Longrightarrow> s_bcorres_underlying t (f >>=E g) (f' >>=E g') s" by (wpsimp simp: bindE_def lift_def split: sum.splits | rule conj... | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | s_bcorres_underlying_splitE | |
get_s_bcorres_underlyingE [wp]: "s_bcorres_underlying t (f s) (f' (t s)) s \<Longrightarrow> s_bcorres_underlying t (liftE get >>=E f) (liftE get >>=E f') s" by (simp add: gets_def s_bcorres_underlying_def get_def bindE_def bind_def return_def liftE_def lift_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | get_s_bcorres_underlyingE | |
bcorres_underlying_splitE [wp_split]: "(\<And>r. bcorres_underlying t (g r) (g' r)) \<Longrightarrow> bcorres_underlying t f f' \<Longrightarrow> bcorres_underlying t (f >>=E g) (f' >>=E g')" by (simp add: bcorres_underlying_def s_bcorres_underlying_splitE) lemmas return_s_bcorres_underlying[wp] = drop_sbcorres_underly... | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | bcorres_underlying_splitE | |
liftE_s_bcorres_underlying [wp]: "s_bcorres_underlying t f f' s \<Longrightarrow> s_bcorres_underlying t (liftE f) (liftE f') s" by (wpsimp simp: liftE_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | liftE_s_bcorres_underlying | |
liftE_bcorres_underlying [wp]: "bcorres_underlying t f f' \<Longrightarrow> bcorres_underlying t (liftE f) (liftE f')" by (simp add: bcorres_underlying_def liftE_s_bcorres_underlying) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | liftE_bcorres_underlying | |
returnOk_bcorres_underlying [wp]: "bcorres_underlying t (returnOk x) (returnOk x)" by (wpsimp simp: returnOk_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | returnOk_bcorres_underlying | |
whenE_s_bcorres_underlying [wp]: "\<lbrakk> \<lbrakk>P = P'; P\<rbrakk> \<Longrightarrow> s_bcorres_underlying t f f' s; P = P' \<rbrakk> \<Longrightarrow> s_bcorres_underlying t (whenE P f) (whenE P' f') s" by (wpsimp simp: whenE_def|rule drop_sbcorres_underlying)+ | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | whenE_s_bcorres_underlying | |
select_s_bcorres_underlying [wp]: "A \<subseteq> B \<Longrightarrow> s_bcorres_underlying t (select A) (select B) s" by (simp add: s_bcorres_underlying_def select_def image_def) blast | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | select_s_bcorres_underlying | |
fail_s_bcorres_underlying [wp]: "s_bcorres_underlying t fail fail s" by (simp add: s_bcorres_underlying_def fail_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | fail_s_bcorres_underlying | |
fail_bcorres_underlying [wp]: "bcorres_underlying t fail fail" by (simp add: bcorres_underlying_def fail_s_bcorres_underlying) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | fail_bcorres_underlying | |
assertE_bcorres_underlying [wp]: "bcorres_underlying t (assertE P) (assertE P)" by (wpsimp simp: assertE_def returnOk_def|rule conjI)+ lemmas assertE_s_bcorres_underlying[wp] = drop_sbcorres_underlying[OF assertE_bcorres_underlying] | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | assertE_bcorres_underlying | |
when_s_bcorres_underlying [wp]: "(P \<Longrightarrow> s_bcorres_underlying t f f' s) \<Longrightarrow> s_bcorres_underlying t (when P f) (when P f') s" by (simp add: return_s_bcorres_underlying when_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | when_s_bcorres_underlying | |
when_bcorres_underlying [wp]: "(P \<Longrightarrow> bcorres_underlying t f f') \<Longrightarrow> bcorres_underlying t (when P f) (when P f')" by (simp add: bcorres_underlying_def when_s_bcorres_underlying) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | when_bcorres_underlying | |
put_bcorres_underlying [wp]: "t f = f' \<Longrightarrow> bcorres_underlying t (put f) (put f')" by (simp add: bcorres_underlying_def s_bcorres_underlying_def put_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | put_bcorres_underlying | |
modify_bcorres_underlying [wp]: "(\<And>x. t (f x) = f' (t x)) \<Longrightarrow> bcorres_underlying t (modify f) (modify f')" by (wpsimp simp: modify_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | modify_bcorres_underlying | |
liftM_bcorres_underlying [wp]: "bcorres_underlying t m m' \<Longrightarrow> bcorres_underlying t (liftM f m) (liftM f m')" by (wpsimp simp: liftM_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | liftM_bcorres_underlying | |
sequence_x_bcorres_underlying [wp]: "(\<And>x. bcorres_underlying t (f x) (f' x)) \<Longrightarrow> bcorres_underlying t (sequence_x (map f xs)) (sequence_x (map f' xs))" by (induct xs; wpsimp simp: sequence_x_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | sequence_x_bcorres_underlying | |
sequence_bcorres_underlying [wp]: "(\<And>x. bcorres_underlying t (f x) (f' x)) \<Longrightarrow> bcorres_underlying t (sequence (map f xs)) (sequence (map f' xs))" by (induct xs; wpsimp simp: sequence_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | sequence_bcorres_underlying | |
mapM_x_bcorres_underlying [wp]: "(\<And>x. bcorres_underlying t (f x) (f' x)) \<Longrightarrow> bcorres_underlying t (mapM_x f xs) (mapM_x f' xs)" by (wpsimp simp: mapM_x_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | mapM_x_bcorres_underlying | |
mapM_bcorres_underlying [wp]: "(\<And>x. bcorres_underlying t (f x) (f' x)) \<Longrightarrow> bcorres_underlying t (mapM f xs) (mapM f' xs)" by (simp add: mapM_def | wp)+ | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | mapM_bcorres_underlying | |
gets_s_bcorres_underlyingE ': "s_bcorres_underlying t (f (x s)) (f' (x' (t s))) s \<Longrightarrow> s_bcorres_underlying t (liftE (gets x) >>=E f) (liftE (gets x') >>=E f') s" by (simp add: gets_def liftE_def lift_def bindE_def) wp | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | gets_s_bcorres_underlyingE | |
bcorres_underlying_filterM [wp]: "(\<And>x. bcorres_underlying t (a x) (a' x)) \<Longrightarrow> bcorres_underlying t (filterM a b) (filterM a' b)" by (induct b; wpsimp simp: filterM_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | bcorres_underlying_filterM | |
option_rec_bcorres_underlying [wp_split]: "(\<And>x y. bcorres_underlying t (g x y) (g' x y)) \<Longrightarrow> (\<And>x. bcorres_underlying t (f x) (f' x)) \<Longrightarrow> bcorres_underlying t (rec_option f g a b) (rec_option f' g' a b)" by (cases a, simp+) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | option_rec_bcorres_underlying | |
bcorres_underlying_mapME [wp]: "(\<And>x. bcorres_underlying t (f x) (f' x)) \<Longrightarrow> bcorres_underlying t (mapME f r) (mapME f' r)" by (induct r; wpsimp simp: mapME_def sequenceE_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | bcorres_underlying_mapME | |
handle2_bcorres_underlying [wp]: "bcorres_underlying t f f' \<Longrightarrow> (\<And>x. bcorres_underlying t (g x) (g' x)) \<Longrightarrow> bcorres_underlying t (f <handle2> g) (f' <handle2> g')" by (wpsimp simp: handleE'_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | handle2_bcorres_underlying | |
liftME_bcorres_underlying [wp]: "bcorres_underlying t f f' \<Longrightarrow> bcorres_underlying t (liftME a f) (liftME a f')" by (wpsimp simp: liftME_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | liftME_bcorres_underlying | |
zipWithM_x_bcorres [wp]: "(\<And>x y. bcorres_underlying t (f x y) (f' x y) ) \<Longrightarrow> bcorres_underlying t (zipWithM_x f xs ys) (zipWithM_x f' xs ys)" by (wpsimp simp: zipWithM_x_def zipWith_def split_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | zipWithM_x_bcorres | |
mapME_x_bcorres_underlying [wp]: "(\<And>x. bcorres_underlying t (f x) (f' x)) \<Longrightarrow> bcorres_underlying t (mapME_x f xs) (mapME_x f' xs)" by (induct xs; wpsimp simp: mapME_x_def sequenceE_x_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | mapME_x_bcorres_underlying | |
liftE_bind_bcorres [wp]: "bcorres_underlying t (f >>= g) (f' >>= g') \<Longrightarrow> bcorres_underlying t (liftE f >>=E g) (liftE f' >>=E g')" by (simp add: gets_def bcorres_underlying_def s_bcorres_underlying_def get_def bind_def return_def split_def liftE_def bindE_def lift_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | liftE_bind_bcorres | |
select_f_bcorres [wp]: "bcorres_underlying t (select_f f) (select_f f)" by (fastforce simp: select_f_def bcorres_underlying_def s_bcorres_underlying_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | select_f_bcorres | |
bcorres_underlying_if [wp]: "(b \<Longrightarrow> bcorres_underlying t f f') \<Longrightarrow> (\<not>b \<Longrightarrow> bcorres_underlying t g g') \<Longrightarrow> bcorres_underlying t (if b then f else g) (if b then f' else g')" by (case_tac b; simp) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | bcorres_underlying_if | |
assert_opt_bcorres_underlying [wp]: "bcorres_underlying t (assert_opt f) (assert_opt f)" by (wpsimp simp: assert_opt_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | assert_opt_bcorres_underlying | |
unlessb_corres_underlying [wp]: "bcorres_underlying t f f' \<Longrightarrow> bcorres_underlying t (unless a f) (unless a f')" by (wpsimp simp: unless_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | unlessb_corres_underlying | |
select_bcorres_underlying [wp]: "A \<subseteq> B \<Longrightarrow> bcorres_underlying t (select A) (select B)" by (fastforce simp: bcorres_underlying_def select_def s_bcorres_underlying_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | select_bcorres_underlying | |
catch_bcorres [wp]: "bcorres_underlying t f f' \<Longrightarrow> (\<And>x. bcorres_underlying t (g x) (g' x)) \<Longrightarrow> bcorres_underlying t (f <catch> g) (f' <catch> g')" unfolding catch_def by wpsimp | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | catch_bcorres | |
whenE_bcorres_underlying [wp]: "\<lbrakk> \<lbrakk>P = P'; P\<rbrakk> \<Longrightarrow> bcorres_underlying t f f'; P = P' \<rbrakk> \<Longrightarrow> bcorres_underlying t (whenE P f) (whenE P' f')" unfolding whenE_def by wpsimp | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | whenE_bcorres_underlying | |
unlessE_bcorres [wp]: "bcorres_underlying t f f' \<Longrightarrow> bcorres_underlying t (unlessE P f) (unlessE P f')" by (wpsimp simp: unlessE_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | unlessE_bcorres | |
alternative_bcorres [wp]: "\<lbrakk> bcorres_underlying t f f'; bcorres_underlying t g g' \<rbrakk> \<Longrightarrow> bcorres_underlying t (f \<sqinter> g) (f' \<sqinter> g')" by (fastforce simp: alternative_def bcorres_underlying_def s_bcorres_underlying_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | alternative_bcorres | |
gets_the_bcorres_underlying [wp]: "(\<And>s. f' (t s) = f s) \<Longrightarrow> bcorres_underlying t (gets_the f) (gets_the f')" by (wpsimp simp: gets_the_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | gets_the_bcorres_underlying | |
maybeM_bcorres_underlying [wp]: "\<lbrakk>\<And>x. y = Some x \<Longrightarrow> bcorres_underlying t (f x) (f' x)\<rbrakk> \<Longrightarrow> bcorres_underlying t (maybeM f y) (maybeM f' y)" by (wpsimp simp: maybeM_def) ML \<open> structure CrunchBCorresInstance : CrunchInstance = struct val name = "bcorres"; val prefix... | lemma | lib | [
"Monads.Nondet_VCG",
"Crunch_Instances_NonDet"
] | lib/BCorres_UL.thy | maybeM_bcorres_underlying | |
bisim_underlying :: "('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> (('c \<times> 'a) set) \<times> bool) \<Rightarrow> ('b \<Rightarrow> (('d \<times> 'b) set) \<... | definition | lib | [
"Monads.Nondet_VCG",
"Corres_UL",
"Monads.Nondet_Empty_Fail"
] | lib/Bisim_UL.thy | bisim_underlying | |
bisim_is_corres_both_ways : "bisim_underlying SR R P P' m m' = (corres_underlying SR False R P P' m m' \<and> corres_underlying (converse SR) False (swp R) P' P m' m)" unfolding bisim_underlying_def corres_underlying_def by (fastforce simp: swp_def Ball_def Bex_def) *) | lemma | lib | [
"Monads.Nondet_VCG",
"Corres_UL",
"Monads.Nondet_Empty_Fail"
] | lib/Bisim_UL.thy | bisim_is_corres_both_ways | |
bisim_valid : assumes ac: "bisim_underlying (=) (=) P P' a a'" and rl: "\<lbrace>Q\<rbrace> a \<lbrace>S\<rbrace>" shows "\<lbrace>P and P' and Q\<rbrace> a' \<lbrace>S\<rbrace>" using ac rl unfolding bisim_underlying_def valid_def by (fastforce simp: split_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Corres_UL",
"Monads.Nondet_Empty_Fail"
] | lib/Bisim_UL.thy | bisim_valid | |
bisim_valid2 : assumes ac: "bisim_underlying (=) (=) P P' a a'" and rl: "\<lbrace>Q\<rbrace> a' \<lbrace>S\<rbrace>" shows "\<lbrace>P and P' and Q\<rbrace> a \<lbrace>S\<rbrace>" using ac rl unfolding bisim_underlying_def valid_def by (fastforce simp: split_def) | lemma | lib | [
"Monads.Nondet_VCG",
"Corres_UL",
"Monads.Nondet_Empty_Fail"
] | lib/Bisim_UL.thy | bisim_valid2 | |
bisim_underlyingI [consumes 0, case_names Left Right]: assumes r1: "\<And>s s' r t. \<lbrakk>SR s s'; P s; P' s'; (r, t) \<in> fst (m s) \<rbrakk> \<Longrightarrow> \<exists>(r', t') \<in> fst (m' s'). R r r' \<and> SR t t'" and r2: "\<And>s s' r' t'. \<lbrakk>SR s s'; P s; P' s'; (r', t') \<in> fst (m' s') \<rbrakk> \... | lemma | lib | [
"Monads.Nondet_VCG",
"Corres_UL",
"Monads.Nondet_Empty_Fail"
] | lib/Bisim_UL.thy | bisim_underlyingI | |
bisim_underlyingE1 : assumes bs: "bisim_underlying SR R P P' m m'" and sr: "SR s s'" and ps: "P s" "P' s'" and ms: "(r, t) \<in> fst (m s)" and rl: "\<And>r' t'. \<lbrakk> (r', t') \<in> fst (m' s'); R r r'; SR t t' \<rbrakk> \<Longrightarrow> X" shows X using bs sr ps ms unfolding bisim_underlying_def by (fastforce in... | lemma | lib | [
"Monads.Nondet_VCG",
"Corres_UL",
"Monads.Nondet_Empty_Fail"
] | lib/Bisim_UL.thy | bisim_underlyingE1 | |
bisim_underlyingE2 : assumes bs: "bisim_underlying SR R P P' m m'" and sr: "SR s s'" and ps: "P s" "P' s'" and ms: "(r', t') \<in> fst (m' s')" and rl: "\<And>r t. \<lbrakk> (r, t) \<in> fst (m s); R r r'; SR t t' \<rbrakk> \<Longrightarrow> X" shows X using bs sr ps ms unfolding bisim_underlying_def by (fastforce intr... | lemma | lib | [
"Monads.Nondet_VCG",
"Corres_UL",
"Monads.Nondet_Empty_Fail"
] | lib/Bisim_UL.thy | bisim_underlyingE2 |
End of preview. Expand in Data Studio
Isabelle-seL4
Structured dataset from l4v - formal verification proofs for the seL4 microkernel.
74,086 declarations extracted from Isabelle theory files.
One of the largest machine-checked proofs of operating system code ever completed.
Applications
- Training language models on formal proofs
- Fine-tuning theorem provers
- Retrieval-augmented generation for proof assistants
- Learning proof embeddings and representations
Source
- Repository: https://github.com/seL4/l4v
- License: GPL-2.0 (kernel proofs) + BSD-2-Clause (libraries)
Schema
| Column | Type | Description |
|---|---|---|
| fact | string | Declaration body |
| type | string | theorem, lemma, definition, etc. |
| library | string | Source module |
| imports | list | Required imports |
| filename | string | Source file path |
| symbolic_name | string | Identifier |
- Downloads last month
- 5