hcju/isabelleps huggingface dataset:
enc_wf_interp: fixes I :: "(nat + nat set) list"   and \<phi> :: "'a formula"   and w :: "'a list"   and x :: "('a \<times> bool list) list" assumes "wf_formula (length I) \<phi>"   and "wf_interp_for_formula (w, I) \<phi>"   and "x \<in> enc (w, I)" shows "wf_interp_for_formula (dec_word (x @- sconst (any, replicate (length I) False)), stream_dec (length I) (FOV \<phi>) (x @- sconst (any, replicate (length I) False))) \<phi>"
intro: fixes ts :: "('b \<times> instr list \<times> (nat \<Rightarrow> nat option) \<times> 'b memref list \<times> bool \<times> nat set \<times> (nat \<Rightarrow> bool option)) list" assumes "load_tmps_distinct ts"   and "read_tmps_distinct ts"   and "load_tmps_read_tmps_distinct ts" shows "tmps_distinct ts"
bounded_Max_nat: fixes P :: "nat \<Rightarrow> bool"   and x :: "nat"   and M :: "nat" assumes "P x"   and "\<And>x. P x \<Longrightarrow> x \<le> M" obtains m :: "nat" where "P m" and "\<And>x. P x \<Longrightarrow> x \<le> m"
P'B'Q': shows "(P', B', Q') = diagonal_to_Smith_aux_PQ [0..<k] bezout (P, B, Q)"
F_one: fixes g :: "'d \<Rightarrow> 'c"   and A :: "'d set" shows "aggregation.sum_0 g A + zero = aggregation.sum_0 g A"
le_mono: fixes x :: "real"   and bs :: "real list" shows "\<forall>a n s. Inum (x # bs) a = Inum (x # bs) (CN 0 n s) \<and> numbound0 s \<longrightarrow> Ifm (x # bs) (le n s) = Ifm (x # bs) (Le a)"
lfp_dual: shows "\<partial> \<circ> lfp = gfp \<circ> \<partial>\<^sub>F"
smatch_list_comb_is_value: fixes t :: "sterm"   and name :: "name"   and ps :: "Term_Class.term list" assumes "is_value t" shows "match (name $$ ps) t = (case strip_comb t of (Sconst name', vs) \<Rightarrow> if name = name' \<and> length ps = length vs then map_option (foldl (++\<^sub>f) fmempty) (those (Term_Utils.map2 match ps vs)) else None | (Svar x, vs) \<Rightarrow> Map.empty x | (Sabs x, vs) \<Rightarrow> Map.empty x | (sterm1 $\<^sub>s x, vs) \<Rightarrow> Map.empty x)"
assms_2: shows "\<HH> : \<AA> \<mapsto>\<mapsto>\<^sub>D\<^sub>G\<^sub>.\<^sub>t\<^sub>m\<^bsub>\<alpha>\<^esub> \<BB>"
ennreal_SUP_countable_SUP: fixes A :: "'b set"   and g :: "'b \<Rightarrow> ennreal" assumes "A \<noteq> {}" shows "\<exists>f. range f \<subseteq> g ` A \<and> Sup (g ` A) = Sup (range f)"
star_denest: fixes x :: "'b \<times> 'c"   and y :: "'b \<times> 'c" shows "prod.qstar (sup_prod x y) = prod.qstar (times_prod' (prod.qstar x) (prod.qstar y))"
root_rat_floor_def: fixes p :: "nat"   and x :: "rat" shows "root_rat_floor p x \<equiv> case quotient_of x of (a, b) \<Rightarrow> root_int_floor p (a * b ^ (p - 1)) div b"
space_state_measureD_shift: fixes \<sigma> :: "nat \<Rightarrow> val"   and V :: "nat set"   and t :: "pdf_type"   and \<Gamma> :: "nat \<Rightarrow> pdf_type" assumes "\<sigma> \<in> space (state_measure (shift_var_set V) (case_nat t \<Gamma>))" shows "\<exists>x \<sigma>'. x \<in> type_universe t \<and> \<sigma>' \<in> space (state_measure V \<Gamma>) \<and> \<sigma> = case_nat x \<sigma>'"
to_stream_in_streams: fixes X :: "nat \<Rightarrow> 'a"   and S :: "'a set" shows "(to_stream X \<in> streams S) = (\<forall>n. X n \<in> S)"
open_inter: fixes S :: "'c set"   and is_open :: "'c set \<Rightarrow> bool"   and U :: "'c set"   and V :: "'c set" assumes "topological_space S is_open"   and "is_open U"   and "is_open V" shows "is_open (U \<inter> V)"
wt: shows "\<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>e\<Colon>-T"
nvL_varsL: fixes x :: "Preliminaries.var"   and l :: "('c, 'd) lit" assumes "x \<in> nvL l" shows "x \<in> varsL l"
ex_un_null: shows "\<exists>!n. \<forall>f. L.comp n f = n \<and> L.comp f n = n"
left_commute: fixes b :: "'d DBMEntry"   and a :: "'d DBMEntry"   and c :: "'d DBMEntry" shows "dbm_add b (dbm_add a c) = dbm_add a (dbm_add b c)"
gs_sub: shows "fst ` set gs \<subseteq> dgrad_p_set d m"
unstream_splice_trans_Left_only: fixes g :: "('e, 'f) generator"   and h :: "('e, 'g) generator"   and sg :: "'f" shows "unstream (splice_trans g h) (Left_only sg) = unstream g sg"
obv: shows "(reduce_mat_cols (M_mat signs subsets) (solve_for_lhs p qs subsets (M_mat signs subsets)))\<^sup>T \<in> carrier_mat (dim_row (reduce_mat_cols (M_mat signs subsets) (solve_for_lhs p qs subsets (M_mat signs subsets)))\<^sup>T) (dim_col (reduce_mat_cols (M_mat signs subsets) (solve_for_lhs p qs subsets (M_mat signs subsets)))\<^sup>T)"
reachable_s_non_empty: fixes PROB :: "(('a, 'b) fmap \<times> ('a, 'b) fmap) set"   and s :: "('a, 'b) fmap" shows "reachable_s PROB s \<noteq> {}"
gen_step_def: fixes s :: "('a, 'c) state_scheme" shows "a.a.gen_dfs.gen_step s \<equiv> if gds_is_empty_stack a.a.gen_dfs.gds s then SPEC (\<lambda>v0. v0 \<in> a.a.V0 \<and> \<not> gds_is_discovered a.a.gen_dfs.gds v0 s) \<bind> (\<lambda>v0. gds_new_root a.a.gen_dfs.gds v0 s) else gds_get_pending a.a.gen_dfs.gds s \<bind> (\<lambda>(u, Vs, s). case Vs of None \<Rightarrow> gds_finish a.a.gen_dfs.gds u s | Some v \<Rightarrow> if gds_is_discovered a.a.gen_dfs.gds v s then if gds_is_finished a.a.gen_dfs.gds v s then gds_cross_edge a.a.gen_dfs.gds u v s else gds_back_edge a.a.gen_dfs.gds u v s else gds_discover a.a.gen_dfs.gds u v s)"
ring_hom_restrict: fixes f :: "'a \<Rightarrow> 'e"   and S :: "('e, 'f) ring_scheme"   and g :: "'a \<Rightarrow> 'e" assumes "f \<in> ring_hom R S"   and "\<And>r. r \<in> carrier R \<Longrightarrow> f r = g r" shows "g \<in> ring_hom R S"
urel_integer_0: fixes pp :: "integer" assumes "p = int_of_integer pp" shows "urel_integer 0 0"
Entry_iff_unreachable: fixes g :: "'g"   and n :: "'node" assumes "invar g"   and "n \<in> set (\<alpha>n g)" shows "(predecessors g n = []) = (n = Entry g)"
simps_39: fixes f1 :: "nat \<Rightarrow> nat list \<Rightarrow> 'a"   and f2 :: "nat \<Rightarrow> nat list \<Rightarrow> 'a"   and f3 :: "form \<Rightarrow> form \<Rightarrow> 'a"   and f4 :: "form \<Rightarrow> form \<Rightarrow> 'a"   and f5 :: "form \<Rightarrow> 'a"   and f6 :: "form \<Rightarrow> 'a"   and x31 :: "form"   and x32 :: "form" shows "(case FConj x31 x32 of PAtom x xa \<Rightarrow> f1 x xa | NAtom x xa \<Rightarrow> f2 x xa | FConj x xa \<Rightarrow> f3 x xa | FDisj x xa \<Rightarrow> f4 x xa | FAll x \<Rightarrow> f5 x | FEx x \<Rightarrow> f6 x) = f3 x31 x32"
h0a: shows "dim_col (take_cols_from_matrix (alt_matrix_A signs subsets) S) = length (take_indices signs S)"
unit_simps_2: fixes a :: "'c" assumes "C.obj a" shows "src\<^sub>D (H.unit a) = H.map\<^sub>0 a"
countable_Un: fixes A :: "'c set"   and B :: "'c set" assumes "countable A"   and "countable B" shows "countable (A \<union> B)"
inv_solve_right': fixes a :: "'a"   and b :: "'a"   and c :: "'a" assumes "a \<in> carrier G"   and "b \<in> carrier G"   and "c \<in> carrier G" shows "(b \<otimes> inv c = a) = (b = a \<otimes> c)"
has_sort_Tv_refl': fixes \<Theta> :: "((String.literal \<Rightarrow> typ option) \<times> (String.literal \<Rightarrow> nat option) \<times> (String.literal \<times> String.literal) set \<times> (String.literal \<Rightarrow> (String.literal \<Rightarrow> String.literal set list option) option)) \<times> Core.term set"   and v :: "variable"   and S :: "String.literal set" assumes "wf_theory \<Theta>"   and "typ_ok \<Theta> (Tv v S)" shows "has_sort (osig (sig \<Theta>)) (Tv v S) S"
healthy_monoD2: fixes t :: "('a \<Rightarrow> real) \<Rightarrow> 'a \<Rightarrow> real"   and P :: "'a \<Rightarrow> real"   and Q :: "'a \<Rightarrow> real" assumes "healthy t"   and "sound P"   and "sound Q"   and "P \<tturnstile> Q" shows "t P \<tturnstile> t Q"
ennreal_add_eq_top: fixes a :: "ennreal"   and b :: "ennreal" shows "(a + b = top) = (a = top \<or> b = top)"
distinct_57: fixes x8 :: "'a" shows "Integer \<noteq> \<langle>x8\<rangle>\<^sub>\<T>"
widen_null: fixes P :: "'b prog"   and C :: "char list" shows "P \<turnstile> NT \<le> Class C"
is_standard_effect_def: shows "is_standard_effect \<equiv> \<lambda>(pre, uu_, uu_, uu_). pre = []"
floor_divide_of_int_eq: fixes k :: "int"   and l :: "int" shows "\<lfloor>of_int k / of_int l\<rfloor> = k div l"
visible_method_exists: fixes P :: "'a prog"   and C :: "String.literal"   and M :: "String.literal"   and Ts :: "ty list"   and T :: "ty"   and m :: "'a option"   and D :: "String.literal" assumes "P \<turnstile> C sees M: Ts\<rightarrow>T = m in D" shows "\<exists>D' fs ms. class P D = \<lfloor>(D', fs, ms)\<rfloor> \<and> map_of ms M = \<lfloor>(Ts, T, m)\<rfloor>"
Top_prop: fixes x :: "'a" assumes "x \<in> A" shows "(x, Top cl) \<in> r"
four_one: fixes \<delta>S :: "real"   and i :: "nat" assumes "\<beta> \<le> rmin"   and "\<mu> \<le> \<delta>S"   and "\<gamma>1 \<delta>S \<le> \<delta>S" shows "okmaxsync i \<delta>S"
bl_word_not: fixes w :: "'b word" shows "to_bl (NOT w) = map Not (to_bl w)"
cases: fixes x :: "complex \<times> complex \<times> complex \<times> complex" obtains a :: "complex" and b :: "complex" and c :: "complex" and d :: "complex" where "x = (a, b, c, d)"
P3: shows "Bet X' B' C'' \<and> Cong B' C'' B C"
elims_1: fixes x :: "Monitor.args"   and xa :: "nat"   and xb :: "nat"   and xc :: "nat \<times> nat queue \<times> nat \<times> bool list \<times> bool list \<times> ('a option list, nat) mapping \<times> (nat, ('a option list, nat + nat) mapping) mapping \<times> 'a option list set list \<times> nat"   and xd :: "(nat \<times> 'a option list set \<times> 'a option list set) list"   and y :: "bool" assumes "valid_mmuaux' x xa xb xc xd = y" obtains args :: "Monitor.args" and cur :: "nat" and dt :: "nat" and tp :: "nat" and tss :: "nat queue" and len :: "nat" and maskL :: "bool list" and maskR :: "bool list" and a1_map :: "('a option list, nat) mapping" and a2_map :: "(nat, ('a option list, nat + nat) mapping) mapping" and "done" :: "'a option list set list" and done_length :: "nat" and auxlist :: "(nat \<times> 'a option list set \<times> 'a option list set) list" where "x = args" and "xa = cur" and "xb = dt" and "xc = (tp, tss, len, maskL, maskR, a1_map, a2_map, done, done_length)" and "xd = auxlist" and "y = (args_L args \<subseteq> args_R args \<and> maskL = join_mask (args_n args) (args_L args) \<and> maskR = join_mask (args_n args) (args_R args) \<and> len \<le> tp \<and> length (linearize tss) = len \<and> sorted (linearize tss) \<and> (\<forall>t\<in>set (linearize tss). t \<le> cur \<and> enat cur \<le> enat t + right (args_ivl args)) \<and> table (args_n args) (args_L args) (Mapping.keys a1_map) \<and> Mapping.keys a2_map = {tp - len..tp} \<and> (\<forall>xs\<in>Mapping.keys a1_map. case Mapping.lookup a1_map xs of Some tp' \<Rightarrow> tp' < tp) \<and> (\<forall>tp'\<in>Mapping.keys a2_map. case Mapping.lookup a2_map tp' of Some m \<Rightarrow> table (args_n args) (args_R args) (Mapping.keys m) \<and> (\<forall>xs\<in>Mapping.keys m. case Mapping.lookup m xs of Some tstp \<Rightarrow> tstp_lt tstp (cur - (left (args_ivl args) - 1)) tp \<and> isl tstp = (0 < left (args_ivl args)))) \<and> length done = done_length \<and> length done + len = length auxlist \<and> rev done = map proj_thd (take (length done) auxlist) \<and> Ball (set (take (length done) auxlist)) (check_before (args_ivl args) dt) \<and> sorted (map fst auxlist) \<and> list_all2 (\<lambda>x y. triple_eq_pair x y (\<lambda>tp'. filter_a1_map (args_pos args) tp' a1_map) (\<lambda>ts' tp'. filter_a2_map (args_ivl args) ts' tp' a2_map)) (drop (length done) auxlist) (zip (linearize tss) [tp - len..<tp]))"
Sup_trans_def: fixes S :: "(('a \<Rightarrow> real) \<Rightarrow> 'a \<Rightarrow> real) set" shows "Sup_trans S = (\<lambda>P. Sup_exp {t P |t. t \<in> S})"
case_distrib: fixes h :: "'b \<Rightarrow> 'a"   and f1 :: "'b"   and f2 :: "'c \<Rightarrow> 'b"   and exception :: "'c exception" shows "h (case exception of Fault \<Rightarrow> f1 | OK x \<Rightarrow> f2 x) = (case exception of Fault \<Rightarrow> h f1 | OK x \<Rightarrow> h (f2 x))"
inorder_baldR: fixes l :: "('c \<times> color) tree"   and a :: "'c"   and r :: "('c \<times> color) tree" shows "Tree2.inorder (baldR l a r) = Tree2.inorder l @ a # Tree2.inorder r"
funpow_stability: fixes k :: "nat"   and j :: "nat" assumes "(f ^^ Suc k) a = (f ^^ k) a" shows "((f ^^ j) a, (f ^^ k) a) \<in> leq"
that: fixes xss :: "'a list list" assumes "f = lists_succ xss"   and "distincts xss"   and "map set xss = map set css"   and "map hd xss = map hd css" shows "thesis"
induced_automorphism_ntrivial: fixes X :: "'b set set"   and f :: "'b \<Rightarrow> 'b"   and g :: "'b \<Rightarrow> 'b"   and C0 :: "'b set" assumes "OpposedThinChamberComplexFoldings X f g C0" shows "OpposedThinChamberComplexFoldings.induced_automorphism X f g \<noteq> id"
one_divides: fixes a :: "'a list" assumes "a \<in> carrier (poly_ring R)" shows "\<one>\<^bsub>poly_ring R\<^esub> divides\<^bsub>poly_ring R\<^esub> a"
pred_mono_strong: fixes P :: "'c \<Rightarrow> bool"   and x :: "'c list"   and Pa :: "'c \<Rightarrow> bool" assumes "list_all P x"   and "\<And>z. \<lbrakk>z \<in> set x; P z\<rbrakk> \<Longrightarrow> Pa z" shows "list_all Pa x"
null_sets_restrict_space: fixes \<Omega> :: "'a set"   and M :: "'a measure"   and A :: "'a set" assumes "\<Omega> \<in> sets M" shows "(A \<in> null_sets (restrict_space M \<Omega>)) = (A \<subseteq> \<Omega> \<and> A \<in> null_sets M)"
isint_sub: fixes e :: "MIR.num"   and bs :: "real list"   and c :: "int" assumes "isint e bs" shows "isint (Sub (C c) e) bs"
fPowD: fixes A :: "'a fset"   and B :: "'a fset" assumes "A |\<in>| fPow B" shows "A |\<subseteq>| B"
natural_transformation_axioms: shows "natural_transformation (\<cdot>\<^sub>D) (\<cdot>\<^sub>D) D.map (G \<circ> F) \<eta>"
vertex_2_nat_def: shows "vertex_2 \<equiv> 2"
assm: shows "((\<lambda>x. \<chi>i. f i x) has_derivative (\<lambda>h. \<chi>i. f' i h)) F"
add_mset_diff_bothsides: fixes a :: "'c"   and M :: "'c multiset"   and A :: "'c multiset" shows "add_mset a M - add_mset a A = M - A"
insert: fixes xa :: "'a"   and x :: "'a"   and A :: "'a set" shows "MaxR_singleton.MaxR_opt xa (insert x A) = (if x \<in> Field {(xa, xa)} then Some (case MaxR_singleton.MaxR_opt xa A of None \<Rightarrow> x | Some y \<Rightarrow> MaxR_singleton.maxR xa x y) else MaxR_singleton.MaxR_opt xa A)"
mset_insort_wrt: fixes R :: "('b \<times> 'b) set"   and xs :: "'b list" shows "mset (insort_wrt R xs) = mset xs"
list_remove1_conv_remove1: shows "equal_base.list_remove1 (=) = remove1"
IH_5: shows "((l, delete\<langle>t,s\<rangle>) \<in> set A) = ((l, delete\<langle>t,s\<rangle>) \<in> set (dual\<^sub>l\<^sub>s\<^sub>s\<^sub>t A))"
rSym: fixes R :: "pi"   and S :: "pi" assumes "(R, S) \<in> X" shows "(S, R) \<in> X"
Iface_single_2: fixes \<beta> :: "'b common_primitive \<Rightarrow> ('b, 'c) tagged_packet_scheme \<Rightarrow> ternaryvalue"   and \<alpha> :: "action \<Rightarrow> ('b, 'c) tagged_packet_scheme \<Rightarrow> bool"   and X :: "iface"   and a :: "action"   and p :: "('b, 'c) tagged_packet_scheme" assumes "primitive_matcher_generic \<beta>" shows "matches (\<beta>, \<alpha>) (Match (OIface X)) a p = match_iface X (p_oiface p)"
invariant_includes_reachable: fixes F :: "'b program"   and A :: "'b set" assumes "F \<in> invariant A" shows "reachable F \<subseteq> A"
sorted_lower2: shows "sorted_sublist_map R h xs''' lo (p - Suc 0)"
times_def: fixes x :: "'a"   and y :: "'a" shows "x * y = min x y"
cancels_to_1_fold: fixes x1 :: "bool \<times> 'c"   and x2 :: "bool \<times> 'c"   and xs1 :: "(bool \<times> 'c) list"   and xs2 :: "(bool \<times> 'c) list" assumes "canceling x1 x2" shows "cancels_to_1 (xs1 @ x1 # x2 # xs2) (xs1 @ xs2)"
f\<^sub>2rv: shows "between (vertices f\<^sub>2) r v = (if r = u then [] else between (vertices f) r u @ [u]) @ vs"
bind_ask: fixes f :: "'r \<Rightarrow> 'm"   and g :: "'a \<Rightarrow> 'm" shows "bind (ask f) g = ask (\<lambda>r. bind (f r) g)"
when_apply_cong: fixes C :: "bool"   and C' :: "bool"   and s :: "'c"   and s' :: "'c"   and m :: "'c \<Rightarrow> (('d + unit) \<times> 'c) set \<times> bool"   and m' :: "'c \<Rightarrow> (('d + unit) \<times> 'c) set \<times> bool" assumes "C = C'"   and "s = s'"   and "C' \<Longrightarrow> m s' = m' s'" shows "whenE C m s = whenE C' m' s'"
truncate_up_float: fixes p :: "nat"   and x :: "real" shows "truncate_up p x \<in> float"
invarNT_def: fixes istate :: "'a"   and step :: "'a \<Rightarrow> 'b \<Rightarrow> 'c \<times> 'a"   and T :: "('a, 'b, 'c) trans \<Rightarrow> bool"   and Inv :: "'a \<Rightarrow> bool" shows "BD_Security.invarNT istate step T Inv \<equiv> \<forall>s a ou s'. BD_Security.reachNT istate step T s \<and> Inv s \<and> \<not> T (Trans s a ou s') \<and> step s a = (ou, s') \<longrightarrow> Inv s'"
If_and_if: fixes A :: "'b"   and B :: "'b"   and P :: "bool" shows "If Def P then A else B = (if P then A else B)"
gen_length_def: fixes n :: "nat"   and xs :: "'e list" shows "List.gen_length n xs = n + length xs"
mult_strict_mono': fixes plus :: "'d \<Rightarrow> 'd \<Rightarrow> 'd"   and zero :: "'d"   and minus :: "'d \<Rightarrow> 'd \<Rightarrow> 'd"   and less_eq :: "'d \<Rightarrow> 'd \<Rightarrow> bool"   and less :: "'d \<Rightarrow> 'd \<Rightarrow> bool"   and times :: "'d \<Rightarrow> 'd \<Rightarrow> 'd"   and a :: "'d"   and b :: "'d"   and c :: "'d"   and d :: "'d" assumes "class.linordered_semiring_strict plus zero minus less_eq less times"   and "less a b"   and "less c d"   and "less_eq zero a"   and "less_eq zero c" shows "less (times a c) (times b d)"
unifier_sub2: fixes \<sigma> :: "char list \<Rightarrow> fterm"   and L\<^sub>1 :: "fterm literal set"   and L\<^sub>2 :: "fterm literal set" assumes "unifier\<^sub>l\<^sub>s \<sigma> (L\<^sub>1 \<union> L\<^sub>2)" shows "unifier\<^sub>l\<^sub>s \<sigma> L\<^sub>1 \<and> unifier\<^sub>l\<^sub>s \<sigma> L\<^sub>2"
qtable_empty_unit_table: fixes n :: "nat"   and R :: "'a option list \<Rightarrow> bool"   and P :: "'a option list \<Rightarrow> bool" assumes "qtable n {} R P empty_table" shows "qtable n {} R (\<lambda>v. \<not> P v) (unit_table n)"
degree_cong: fixes x :: "'a pdevs"   and y :: "'b pdevs" assumes "\<And>i. (pdevs_apply x i = (0::'a)) = (pdevs_apply y i = (0::'b))" shows "degree x = degree y"
fmlookup_drop: fixes a :: "'f"   and m :: "'f \<rightharpoonup>\<^sub>f 'e"   and x :: "'f" shows "fmlookup (fmdrop a m) x = (if x \<noteq> a then fmlookup m x else None)"
is_hom_ordD: fixes x :: "'x"   and s :: "'x \<Rightarrow>\<^sub>0 nat"   and t :: "'x \<Rightarrow>\<^sub>0 nat" assumes "is_hom_ord x"   and "deg_pm s = deg_pm t" shows "(s \<preceq> t) = (except s {x} \<preceq> except t {x})"
factorize_int_poly_generic_def: fixes alg :: "int_poly_factorization_algorithm"   and f :: "int poly" shows "factorize_int_poly_generic alg f = (case x_split f of (n, g) \<Rightarrow> if g = 0 then (0, []) else case factorize_int_last_nz_poly alg g of (a, fs) \<Rightarrow> if n = 0 then (a, fs) else (a, (monom 1 1, n - 1) # fs))"
matchC_C_sym: fixes theta :: "(('test, 'atom, 'choice) cmd \<times> ('test, 'atom, 'choice) cmd) set"   and c :: "('test, 'atom, 'choice) cmd"   and d :: "('test, 'atom, 'choice) cmd" assumes "matchC_C theta c d" shows "matchC_C (theta\<inverse>) d c"
bin_rsplit_aux_len: fixes n :: "nat"   and nw :: "nat"   and w :: "int"   and cs :: "int list" assumes "n \<noteq> 0" shows "length (bin_rsplit_aux n nw w cs) = (nw + n - 1) div n + length cs"
subdegree_eq_0_right: fixes f :: "'b fps" assumes "\<exists>g. 1 = g * f" shows "subdegree f = 0"
coeff_0_reflect_poly: fixes p :: "'a poly" shows "poly.coeff (reflect_poly p) 0 = Polynomial.lead_coeff p"
assms: shows "\<BB> \<equiv> {(fold Deriv w (lang r), fold Deriv w (lang s)) |w. w \<in> lists (atoms r \<union> atoms s)}"
rrsmult_distrib_left: fixes r :: "'r"   and f :: "'r \<Rightarrow> 'a"   and g :: "'r \<Rightarrow> 'a" shows "r \<currency> (f + g) = r \<currency> f + r \<currency> g"
fs_deriv: fixes k :: "nat"   and x :: "real" assumes "k \<le> 2 * N"   and "x \<in> {real_of_int a..} - Y" shows "(fs k has_vector_derivative fs (Suc k) x) (at x)"
generator_pow_order: shows "\<^bold>g [^] order \<G> = \<one>"
M_sum: fixes f :: "'a \<Rightarrow> int"   and A :: "'a set" shows "M (\<Sum>x\<in>A. M (f x)) = M (sum f A)"
set_eq_iff: fixes A :: "'f set"   and B :: "'f set" shows "(A = B) = (\<forall>x. (x \<in> A) = (x \<in> B))"
Sigma_Image: fixes A :: "'c set"   and B :: "'c \<Rightarrow> 'b set"   and X :: "'c set" shows "Sigma A B `` X = \<Union> (B ` (X \<inter> A))"
not_is_Msg: fixes m :: "'b" shows "(\<not> is_Msg m) = is_NoMsg m"
span: fixes P :: "'a \<Rightarrow> bool"   and xs :: "'a list" shows "Missing_List.span P xs = (takeWhile P xs, dropWhile P xs)"
dep_tc_def: fixes PROB :: "(('d, 'e) fmap \<times> ('d, 'f) fmap) set" shows "dep_tc PROB = TC (dep PROB)"
trnl\<^sub>\<eta>_eq: fixes u :: "'a"   and v :: "'a"   and \<mu> :: "'a" assumes "ide u"   and "ide v"   and "src f = trg v"   and "src g = trg u"   and "\<mu> \<in> hom (f \<star> v) u" shows "trnl\<^sub>\<eta> v \<mu> = (g \<star> \<mu>) \<cdot> \<a>[g, f, v] \<cdot> (\<eta> \<star> v)"
FD: shows "map_of FDTs (F, D) = \<lfloor>(T, fm)\<rfloor>"
funpow_mono: fixes f :: "'e \<Rightarrow> 'e"   and A :: "'e"   and B :: "'e"   and n :: "nat" assumes "mono f"   and "A \<le> B" shows "(f ^^ n) A \<le> (f ^^ n) B"
assms_3: shows "[p] \<cdot> \<one> = \<zero>"
frameImpE: fixes SCompose :: "'d \<Rightarrow> 'd \<Rightarrow> 'd"   and SImp :: "'d \<Rightarrow> 'e \<Rightarrow> bool"   and SBottom :: "'d"   and SChanEq :: "'f \<Rightarrow> 'f \<Rightarrow> 'e"   and A\<^sub>F :: "name list"   and \<Psi>\<^sub>F :: "'d"   and \<Phi> :: "'e" assumes "assertionAux SCompose SImp SBottom SChanEq"   and "assertionAux.FrameImp SImp (\<langle>A\<^sub>F, \<Psi>\<^sub>F\<rangle>) \<Phi>"   and "A\<^sub>F \<sharp>* \<Phi>" shows "SImp \<Psi>\<^sub>F \<Phi>"
filtersI: fixes F :: "'b set set"   and T :: "'b set set" assumes "{} \<notin> F"   and "\<Union> F \<subseteq> carrier\<^bsub>T\<^esub>"   and "\<And>A B. \<lbrakk>A \<in> F; B \<in> F\<rbrakk> \<Longrightarrow> A \<inter> B \<in> F"   and "\<And>A B. \<lbrakk>A \<in> F; A \<subseteq> B; B \<subseteq> carrier\<^bsub>T\<^esub>\<rbrakk> \<Longrightarrow> B \<in> F" shows "F \<in> Filters\<^bsub>T\<^esub>"
echelon_form_upt_k_0: fixes A :: "(('d, 'e) vec, 'f) vec" shows "echelon_form_upt_k A 0"
limI: fixes X :: "nat \<Rightarrow> 'b"   and L :: "'b" assumes "X \<longlonglongrightarrow> L" shows "lim X = L"
econc_fun_def: fixes E :: "('e \<times> 'c) set"   and R :: "('f \<times> 'd) set" shows "\<Down>\<^sub>E E R \<equiv> \<Down> (\<langle>E, R\<rangle>sum_rel)"
mono_mndet_FD: fixes A :: "'a set"   and P :: "'a \<Rightarrow> 'a process"   and P' :: "'a \<Rightarrow> 'a process" assumes "\<forall>x\<in>A. P x \<le> P' x" shows "mndet A P \<le> mndet A P'"
S4aRNext_successors: fixes rmhist :: "state \<Rightarrow> PrIds \<Rightarrow> histState"   and p :: "PrIds" shows "\<turnstile> ($(S4 rmhist p \<and> ires!p = #NotAResult) \<and> ImpNext p \<and> [HNext rmhist p]_(c p, r p, m p, rmhist!p) \<and> (\<forall>l. $MemInv mm l)) \<and> <RNext rmCh mm ires p>_(m p) \<longrightarrow> (S4 rmhist p \<and> ires!p \<noteq> #NotAResult \<or> S5 rmhist p)$"
euler_step_def: fixes X0 :: "'c set"   and h :: "real" shows "euler_step X0 h = one_step X0 h (\<lambda>X0 hl hu CX. let H = lv_ivl [min hl hu] [max hl hu] in mk_safe CX \<bind> (\<lambda>_. let env = concat ` listset [list_of_eucl ` X0, list_of_eucl ` CX, H] in approx_slp_spec (euler_fas' DIM('c)) (2 * DIM('c)) euler_slp env \<bind> (\<lambda>env. case env of None \<Rightarrow> RETURN None | Some env \<Rightarrow> let res' = take DIM('c) ` env in ASSERT (env_len res' DIM('c)) \<bind> (\<lambda>_. let res = eucl_of_list ` res' in ASSUME (ncc res) \<bind> (\<lambda>_. let err' = drop DIM('c) ` take (DIM('c) * 2) ` env in ASSERT (env_len err' DIM('c)) \<bind> (\<lambda>_. let err = eucl_of_list ` err' in default_reduce_argument_spec \<bind> (\<lambda>ra. reduce_spec ra res \<bind> (\<lambda>res. ASSUME (ncc res) \<bind> (\<lambda>_. safe_set res \<bind> (\<lambda>s. if s then mk_safe res \<bind> (\<lambda>res. RETURN (Some (res, err))) else RETURN None))))))))))"
map_upd_nonempty: fixes t :: "'g \<Rightarrow> 'h option"   and k :: "'g"   and x :: "'h" shows "t(k \<mapsto> x) \<noteq> Map.empty"
birkhoff_sum_1_1: fixes f :: "'a \<Rightarrow> 'b"   and x :: "'a" shows "birkhoff_sum f 0 x = (0::'b)"
fdia_d_simp: fixes x :: "'a"   and y :: "'a" shows " |x\<rangle> ad (ad y) =  |x\<rangle> y"