Input:
lemma Disj_eq_iff [simp]:
  assumes "finite (supp xset1)" and "finite (supp xset2)"
  shows "Disj xset1 = Disj xset2 \<longleftrightarrow> xset1 = xset2"

Output:
using assms unfolding Disj_def
by (metis Conj_eq_iff Not_eq_iff bset.inj_map_strong finite_supp_map_bset_Not)


Input:
lemma (in encoding) indRelEQ_is_equivalence:
  shows "equivalence indRelEQ"

Output:
using indRelEQ_is_preorder indRelEQ_symm unfolding equiv_def preorder_on_def
by blast


Input:
lemma (in poly_set_rev_iterateoi) proper_ro[proper_it]:
  "proper_it' rev_iterateoi rev_iterateoi"

Output:
apply (rule proper_it'I)
by (rule pi_rev_iterateoi)


Input:
lemma interaction_bounded_by_obsf_distinguisher [interaction_bound]:
  "interaction_bounded_by consider (obsf_distinguisher \<A>) bound"
  if [interaction_bound]: "interaction_bounded_by consider \<A> bound"

Output:
unfolding obsf_distinguisher_def
by(rule interaction_bound|simp)+


Input:
lemma rb_sp_Cons :
  assumes "RedBlack prb"
  shows   "subpath (red prb) rv1 (re # res) rv2 (subs prb) =
            ( sub_rel_of (red prb) (subs prb)
            \<and> (rv1 = src re \<or> (rv1, src re) \<in> subs prb)
            \<and> re \<in> edges (red prb)
            \<and> subpath (red prb) (tgt re) res rv2 (subs prb))"

Output:
using assms subs_wf_sub_rel_of wf_sub_rel_of.sp_Cons
by fast


Input:
lemma delete_map_transform_env_delete:
  "delete x (map_transform t (env_delete x ae) \<Gamma>) = delete x (map_transform t ae \<Gamma>)"

Output:
unfolding map_transform_def
by (induction \<Gamma>) auto


Input:
lemma sort_key_embedding_injective:
  "sort_key_embedding x = sort_key_embedding y \<Longrightarrow> x = y"

Output:
apply (induct x arbitrary: y)
apply (metis embed_dir_inj list.distinct(1) list.inject sort_key.exhaust sort_key_embedding.simps)
by (metis fst_conv list.distinct(1) list.inject sort_key.exhaust sort_key_embedding.simps)


Input:
lemma encode_all_operator_effects_valid:
   "t < Suc h \<Longrightarrow>
    sv \<in> atoms (encode_all_operator_effects (\<phi> (prob_with_noop abs_prob)) (operators_of (\<phi> (prob_with_noop abs_prob))) t) \<Longrightarrow>
    valid_state_var sv"

Output:
unfolding encode_all_operator_effects_def foldr_And
by (force simp add: encode_operator_effect_valid)


Input:
lemma oracle\<^sub>n_apply [simp]:
  "oracle\<^sub>n b \<eta> s (i, x) = map_spmf (apsnd (fun_upd s i)) (oracle\<^sub>1 b \<eta> (s i) x)"

Output: by(simp add: oracle\<^sub>n_def)


Input: lemma lset_lconst: "x \<in> lset (lconst b) \<Longrightarrow> x = b"

Output:
apply (induct x "lconst b" arbitrary: b rule: llist.set_induct) subgoal
by (subst (asm) lconst.code) auto subgoal
by (subst (asm) (2) lconst.code) auto done


Input: lemma "\<tau> \<Turnstile> \<delta> (None->isEmpty\<^sub>B\<^sub>a\<^sub>g())"

Output: by(auto simp: OclIsEmpty_def OclValid_def defined_def valid_def False_def True_def bot_fun_def None_fun_def OclAnd_def OclOr_def OclNot_def None_is_valid split: if_split_asm)


Input: lemma coclop_dual: "(coclop::('a::order_with_dual \<Rightarrow> 'a) \<Rightarrow> bool) = clop \<circ> \<partial>\<^sub>F"

Output:
unfolding coclop_def clop_def id_def mono_def map_dual_def comp_def fun_eq_iff le_fun_def
by (metis invol_dual_var ord_dual)


Input: lemma Sup_conv_fun_lub: "Sup = fun_lub Sup"

Output: by(auto simp add: Sup_fun_def fun_eq_iff fun_lub_def intro: arg_cong[where f=Sup])


Input: lemma permutation_lists_fc_succ[intro, simp]: "permutation (lists_fc_succ xss)"

Output:
using lists_fc_succ_permutes
by (auto simp: permutation_permutes)


Input: lemma comm_monoid_mult_ow: "class.comm_monoid_mult = comm_monoid_mult_ow UNIV"

Output:
unfolding class.comm_monoid_mult_def comm_monoid_mult_ow_def class.comm_monoid_mult_axioms_def comm_monoid_mult_ow_axioms_def one_ow_def neutral_ow_def ab_semigroup_mult_ow
by simp


Input:
lemma mono2mono_ltakeWhile[THEN llist.mono2mono, cont_intro, simp]:
  shows monotone_ltakeWhile: "monotone lprefix lprefix (ltakeWhile P)"

Output: by(rule llist.fixp_preserves_mono1[OF ltakeWhile_mono ltakeWhile_conv_fixp]) simp


Input:
lemma PX5d_linear:
  shows "Linear_order (PX5d d)"

Output: by (cases d) (simp_all add: linord_of_list_Linear_order)


Input: lemma divisors_fun_nat: "divisors_fun divisors_nat"

Output:
unfolding divisors_fun_def
using divisors_nat
by auto


Input: theorem gdpr_EF': "gdpr_Kripke \<turnstile> EF sgdpr"

Output:
using gdpr_AT
by (auto simp: gdpr_Kripke_def gdpr_states_def Igdpr_def dest: AT_EF)


Input: lemma es_A2A: "succ_ok \<Longrightarrow> edge_succ (mk_map (mk_graph iG) iM) \<in> arcs (mk_graph iG) \<rightarrow> arcs (mk_graph iG)"

Output:
using succ_ok_imp_permutes
by (auto dest: permutes_in_image)


Input: lemma mirror_pair_equal: "equal_pair (mirror_pair p) = (equal_pair p)"

Output: by (fastforce simp: mirror_pair_def equal_pair_def)


Input:
lemma robdd_equiv_alt_def :
assumes "robdd_invar b1"
    and "robdd_invar b2"
shows "robdd_equiv b1 b2 \<longleftrightarrow> robdd_\<alpha> b1 = robdd_\<alpha> b2"

Output:
using assms
apply (rule_tac robdd_equiv_alt_def_full)
apply (simp_all add: robdd_invar_def robdd_invar_ext_def robdd_invar_vars_def) done


Input: lemma cprank_max1: "cprank_max1 A \<Longrightarrow> cprank_max 1 A"

Output: by (metis One_nat_def dims_tensor0 cprank_max.simps cprank_max0 tensor_add_0_right)


Input:
lemma transfer_update:
  "((=) ===> (=) ===> rel_state (=)) update' update"

Output:
unfolding rel_fun_def
by (auto intro: rel_state_update)


Input:
lemma (in encoding) indRelLST_to_SRel:
  fixes SRel  :: "('procS \<times> 'procS) set"
    and TRel  :: "('procT \<times> 'procT) set"
    and SP SQ :: "'procS"
  assumes rel: "SourceTerm SP \<R>\<lbrakk>\<cdot>\<rbrakk>L<SRel,TRel> SourceTerm SQ"
  shows "(SP, SQ) \<in> SRel"

Output:
using rel
by (simp add: indRelLST.simps)


Input:
lemma k_invariantAD:
  "\<lbrakk> k_isNode ec; k_memb ec A; k_invariant A \<rbrakk>
     \<Longrightarrow> \<exists>acts. lookup aOps (aActs A) ec = Some acts \<and> set acts = set (simAction a ec)"

Output:
unfolding k_invariant_def
by blast


Input: lemma bounded_clinear_cblinfun_scaleC_left[bounded_clinear]: "bounded_clinear cblinfun_scaleC_left"

Output: by transfer (rule bounded_cbilinear.flip[OF bounded_cbilinear_scaleC])


Input:
lemma GNil_append:
  assumes "GNil = G1@G2"
  shows "G1 = GNil \<and> G2 = GNil"

Output:
proof(rule ccontr) assume "\<not> (G1 = GNil \<and> G2 = GNil)" hence "G1@G2 \<noteq> GNil"
using append_g.simps
by (metis \<Gamma>.distinct(1) \<Gamma>.exhaust) thus False
using assms
by auto
qed


Input: lemma continuous_within_tan: "cos z \<noteq> 0 \<Longrightarrow> continuous (at z within s) tan"

Output:
using continuous_at_imp_continuous_within isCont_tan
by blast


Input:
lemma hop_count_zero_oip_dip_sip:
  "paodv i \<TTurnstile> (recvmsg msg_zhops \<rightarrow>) onl \<Gamma>\<^sub>A\<^sub>O\<^sub>D\<^sub>V (\<lambda>(\<xi>, l).
                 (l\<in>{PAodv-:4..PAodv-:5} \<union> {PRreq-:n|n. True} \<longrightarrow>
                          (hops \<xi> = 0 \<longrightarrow> oip \<xi> = sip \<xi>))
                 \<and>
                 ((l\<in>{PAodv-:6..PAodv-:7} \<union> {PRrep-:n|n. True} \<longrightarrow>
                          (hops \<xi> = 0 \<longrightarrow> dip \<xi> = sip \<xi>))))"

Output: by (inv_cterms inv add: onl_invariant_sterms [OF aodv_wf received_msg_inv]) auto


Input: lemma iam_new_sz_rule: "<emp> iam_new_sz n < is_iam Map.empty >"

Output:
unfolding iam_new_sz_def is_iam_def[abs_def]
by (sep_auto simp: iam_new_abs)


Input:
lemma finfun_fst_update: "finfun_fst (f(a $:= bc)) = (finfun_fst f)(a $:= fst bc)"
  and finfun_fst_update_code: "finfun_fst (finfun_update_code f a bc) = (finfun_fst f)(a $:= fst bc)"

Output: by(simp_all add: finfun_fst_def)


Input:
lemma GoTo':
  assumes \<open>A, Suc n \<turnstile> ([], i) # branch\<close> \<open>i \<in> branch_nominals branch\<close>
  shows \<open>A, Suc n \<turnstile> branch\<close>

Output:
using assms GoTo STA_potential
by fast


Input:
lemma CD_on_range:
  shows "CD_on ds A \<subseteq> A \<inter> (\<Union>d\<in>ds. Field (Pd d))"

Output:
using Cd_range unfolding CD_on_def
by blast


Input:
lemma subrobdds_set_mono2 :
  "bs1 \<subseteq> bs2 \<Longrightarrow> (subrobdds_set bs1 \<subseteq> subrobdds_set bs2)"

Output:
unfolding subrobdds_set_def
by auto


Input:
lemma Ln_exp [simp]:
  assumes "-pi < Im(z)" "Im(z) \<le> pi"
    shows "ln(exp z) = z"

Output:
proof (rule exp_complex_eqI) show "\<bar>Im (ln (exp z)) - Im z\<bar> < 2 * pi"
using assms mpi_less_Im_Ln [of "exp z"] Im_Ln_le_pi [of "exp z"]
by auto
qed auto


Input:
lemma rank_invar_hd_cons:
  "\<lbrakk>rank_invar bq; rank t < rank (hd bq)\<rbrakk> \<Longrightarrow> rank_invar (t # bq)"

Output:
apply(cases bq)
apply(auto) done


Input:
lemma not_fresh_FDERIV_floatariths:
  "\<not> fresh_floatariths (FDERIV_floatariths ode_e [0..<DIM('a::executable_euclidean_space)] ds) i \<Longrightarrow>
  length ds = DIM('a) \<Longrightarrow> \<not>fresh_floatariths ode_e i \<or> \<not>fresh_floatariths ds i"

Output: by (induction ode_e) (auto simp: FDERIV_floatariths_def dest!: not_fresh_FDERIV_floatarith)


Input:
lemma get_child_nodes_split:
  "P (invoke (a_get_child_nodes_tups @ xs) ptr ()) =
    ((known_ptr ptr \<longrightarrow> P (get_child_nodes ptr))
    \<and> (\<not>(known_ptr ptr) \<longrightarrow> P (invoke xs ptr ())))"

Output: by(auto simp add: known_ptr_impl get_child_nodes_impl a_get_child_nodes_def a_get_child_nodes_tups_def known_ptr_defs CharacterDataClass.known_ptr_defs ElementClass.known_ptr_defs NodeClass.known_ptr_defs split: invoke_splits)


Input:
lemma is_accessible: "low_equal s1 s2 \<Longrightarrow>
virt_to_phys addra (mmu s1) (mem s1) = Some (a, b) \<Longrightarrow>
virt_to_phys addra (mmu s2) (mem s2) = Some (a, b) \<Longrightarrow>
mmu_readable (get_acc_flag b) 10 \<Longrightarrow>
mem_equal s1 s2 a"

Output:
apply (simp add: low_equal_def)
apply (simp add: user_accessible_def)
by fastforce


Input: lemma domo_narrow_subset: "domo (S1 \<triangle> S2) \<subseteq> domo S1 \<union> domo S2"

Output:
apply(induction S1 S2 rule: narrow_option.induct)
apply (auto simp: domo_def narrow_st_def) done


Input:
lemma isduu:
  \<open>is_up UCAST\<close> if \<open>is_down d\<close>
    for d :: \<open>'b word \<Rightarrow> 'a word\<close>

Output:
using that is_up_down [of UCAST d]
by simp


Input: lemma cf_map_vdomain[cat_map_cs_simps]: "\<D>\<^sub>\<circ> (cf_map \<FF>) = 2\<^sub>\<nat>"

Output:
unfolding cf_map_def
by (simp add: nat_omega_simps)


Input:
lemma
  notes [poincare_tac_theorems] = vdp_pi_0 vdp_ro vdp_start
  shows "\<forall>x\<in>{(1.41, 2.25) .. (1.42, 2.25)}.
  vdp.returns_to   {(1, 2.25) .. (2, 2.25)} x \<and>
  vdp.poincare_map {(1, 2.25) .. (2, 2.25)} x \<in> {(1.41, 2.25) .. (1.42, 2.25)}"

Output:
unfolding ninequarters
by (tactic \<open>poincare_bnds_tac @{thms vdp_fas_def} 30 20 7 14 [(0, 1, "0x000000")] "" (* "out_p0_vdp_0.out" *) @{context} 1\<close>)


Input:
lemma Bossy_CH_BCh:
  shows "Bossy.CH X = BCh h1 X \<union> BCh h3 X" (is "?lhs = ?rhs")

Output:
proof(rule equalityI) show "?lhs \<subseteq> ?rhs" unfolding Bossy.CH_def
by clarsimp (simp add: BCh_def split: if_splits) show "?rhs \<subseteq> ?lhs" unfolding Bossy.CH_def
by blast
qed


Input:
lemma line_integral_exists_on_typeII_Cube_boundaries':
  assumes "(k,\<gamma>) \<in> boundary twoC"
  shows "line_integral_exists F {j} \<gamma>"

Output:
using assms GreenThm_typeII_twoCube(2)
by blast


Input: lemma r_trans [simp]: "trans r"

Output:
using r_wo unfolding well_order_on_def linear_order_on_def partial_order_on_def preorder_on_def
by blast


Input:
lemma (in semiring_hom) vector_smult_hom:
  "hom x *s (map_vector hom v) = map_vector hom (x *s v)"

Output: by (transfer fixing: hom, auto simp: vec_hom_smult)


Input: lemma FHModule_addfunset : "FGModule H rrsmult (addfunset FH V)"

Output:
proof (rule FGModule.intro) from FH rrsmult show "RModule Supgroup.group_ring (\<currency>) (addfunset FH V)"
using Group Supgroup.Ring1_RG Ring1.RModule_addfunset
by fast
qed (unfold_locales)


Input: lemma set_cond_spmf [simp]: "set_spmf (cond_spmf p A) = set_spmf p \<inter> A"

Output: by(auto 4 4 simp add: cond_spmf_def in_set_spmf iff: set_cond_pmf[THEN set_eq_iff[THEN iffD1], THEN spec, rotated])


Input: lemma termMOD_igSwapCls: "igSwapCls termMOD"

Output:
unfolding igSwapCls_def
using termMOD_igSwapIGVar termMOD_igSwapIGAbs termMOD_igSwapIGOp
by simp


Input:
lemma radical_sqrt_rule_division:
  "x \<in> radical_sqrt \<Longrightarrow> y \<in> radical_sqrt \<Longrightarrow> y \<noteq> 0 \<Longrightarrow> x/y \<in> radical_sqrt"

Output: by (metis divide_real_def radical_sqrt.intros(3) radical_sqrt.intros(5) real_scaleR_def real_vector.scale_one)


Input:
lemma add_one_2_stop:
  "wprepare_add_one2 m lm (b, Oc # list)
  \<Longrightarrow>  wprepare_stop m lm (tl b, hd b # Oc # list)"

Output: apply(simp add: wprepare_add_one2.simps) done


Input:
lemma valid_add_new_ts_mmsaux:
  assumes "valid_mmsaux args cur aux auxlist" "nt \<ge> cur"
  shows "valid_mmsaux args nt (add_new_ts_mmsaux args nt aux)
    (filter (\<lambda>(t, rel). enat (nt - t) \<le> right (args_ivl args)) auxlist)"

Output: using valid_add_new_ts_mmsaux'[OF valid_shift_end_mmsaux[OF assms] assms(2)] unfolding add_new_ts_mmsaux_def .


Input: lemma r_e2frame_prim: "prim_recfn 1 r_e2frame"

Output:
unfolding r_e2frame_def
using r_hd_prim r_e2stack_prim
by simp


Input:
lemma flush_all_until_volatile_write_unchanged_addresses':
  assumes  notin: "a \<notin> \<Union> ((\<lambda>(_,_,_,sb,_,_,_). outstanding_refs (Not \<circ> is_volatile) sb) ` set ls)"
  shows "flush_all_until_volatile_write ls m a = m a"

Output:
using notin_outstanding_non_volatile_takeWhile_Un_lem' [OF notin]
by (auto intro: flush_all_until_volatile_write_unchanged_addresses)


Input: lemma length_tms_of[simp]: "length (tms_of aprog) = length aprog"

Output: apply(auto simp: tms_of.simps tpairs_of.simps) done


Input:
lemma swapInp_preserves_good[simp]:
assumes "goodInp inp"
shows "goodInp (inp %[x \<and> y]_xs)"

Output:
using assms
by (auto simp: goodInp_def lift_def swapInp_def liftAll_def split: option.splits)


Input:
lemma R_loopI:
  "X \<le> rel_R \<lceil>I\<rceil> \<lceil>I\<rceil> \<Longrightarrow> \<lceil>P\<rceil> \<le> \<lceil>I\<rceil> \<Longrightarrow> \<lceil>I\<rceil> \<le> \<lceil>Q\<rceil> \<Longrightarrow> LOOP X INV I \<le> rel_R \<lceil>P\<rceil> \<lceil>Q\<rceil>"

Output:
unfolding rel_rkat.spec_def
using H_loopI
by blast


Input:
lemma arg_uminus:
  assumes "z \<noteq> 0"
  shows "arg (-z) = \<downharpoonright>arg z + pi\<downharpoonleft>"

Output:
using assms
using arg_mult[of "-1" z]
using arg_complex_of_real_negative[of "-1"]
by (auto simp add: field_simps)


Input:
lemma handshake_obj_fields_markedD:
  "\<lbrakk> atS gc gc.obj_fields_marked_locs s; gc.handshake_invL s \<rbrakk> \<Longrightarrow> sys_ghost_hs_phase s\<down> = hp_IdleMarkSweep \<and> All (ghost_hs_in_sync (s\<down> sys))"

Output:
unfolding gc.handshake_invL_def
by (metis (no_types, lifting) atS_mono gc.obj_fields_marked_locs_subseteq_hp_IdleMarkSweep_locs gc.obj_fields_marked_locs_subseteq_hs_in_sync_locs)


Input:
lemma PO_m3_inv1_lkeysec_trans [iff]:
  "{m3_inv1_lkeysec} trans m3 {> m3_inv1_lkeysec}"

Output: by (fastforce simp add: PO_hoare_defs m3_defs intro!: m3_inv1_lkeysecI)


Input:
lemma is_up_compose:
  "\<lbrakk> is_up uc; is_up uc' \<rbrakk> \<Longrightarrow> is_up (uc' \<circ> uc)"

Output:
unfolding is_up_def
by (simp add: Word.target_size Word.source_size)


Input:
lemma map_of_SomeI:
  "\<lbrakk> distinct_fst kxs; (k,x) \<in> set kxs \<rbrakk> \<Longrightarrow> map_of kxs k = Some x"

Output: by (induct kxs) (auto simp:fun_upd_apply)


Input: lemma bi_total_rel_gpv' [transfer_rule]: "bi_total A \<Longrightarrow> bi_total (rel_gpv' A)"

Output:
unfolding rel_gpv'_def
by(simp add: bi_total_rel_gpv bi_total_eq)


Input:
lemma sym_non_volatile_conflict:
  "symP (non_volatile_conflict P E)"

Output:
unfolding non_volatile_conflict_def
by(rule symPI) blast


Input:
lemma diff_prs[quot_preserve]:
  assumes "Quotient3 R Abs Rep"
  shows "((-`) Abs ---> (-`) Abs ---> (-`) Rep) (-) = (-)"

Output:
unfolding fun_eq_iff
by (simp add: Quotient3_abs_rep[OF set_quotient[OF assms]] vimage_Diff)


Input:
lemma ENF_offending_subseteq_lhs:
    assumes "sinvar_all_edges_normal_form P"
    shows "set_offending_flows G nP \<subseteq> { {(e1,e2). (e1, e2) \<in> edges G \<and> \<not> P (nP e1) (nP e2)} }"

Output:
using assms
by (force simp: ENF_offending_set_P_representation)


Input:
lemma new_element_is_l_new_element [instances]:
  "l_new_element type_wf"

Output:
using l_new_element.intro new_element_type_wf_preserved
by blast


Input: lemma not_additive_principal_0: "\<not> additive_principal 0"

Output: by (clarify, drule additive_principal.not_0, simp)


Input:
lemma combine_inv2:
  assumes "inv2 lt" "inv2 rt" "bheight lt = bheight rt"
  shows "bheight (combine lt rt) = bheight lt" "inv2 (combine lt rt)"

Output:
using assms
by (induct lt rt rule: combine.induct) (auto simp: balance_left_inv2_app split: rbt.splits color.splits)


Input: lemma predCC_eqvt[eqvt, simp]: "\<pi> \<bullet> (predCC S f) = predCC (\<pi> \<bullet> S) (\<pi> \<bullet> f)"

Output:
apply (rule cfun_eqvtI) unfolding predCC_eq
by perm_simp rule


Input:
lemma loose_bvar1_subst_bvs1'_closeds: "\<not> loose_bvar1 t lev \<Longrightarrow> lev < k \<Longrightarrow> \<forall>x\<in>set us . is_closed x
  \<Longrightarrow> \<not> loose_bvar1 (subst_bvs1' t k us) lev"

Output: by (induction t k us arbitrary: lev rule: subst_bvs1'.induct) (use is_open_def loose_bvar_iff_exist_loose_bvar1 in \<open>auto simp add: is_open_def\<close>)


Input:
lemma monotone_map_prod [simp]:
  "monotone (rel_prod orda ordb) (rel_prod ordc ordd) (map_prod f g) \<longleftrightarrow>
   monotone orda ordc f \<and> monotone ordb ordd g"

Output: by(auto simp add: monotone_def)


Input:
lemma e2tail_tail [simp]:
  "e2tail (encode_config (s # ss, rv)) = list_encode (map encode_frame ss)"

Output:
unfolding e2tail_def
using encode_config
by fastforce


Input: lemma bind_option_option [simp]: "monad.bind_option None = Option.bind"

Output: by(simp add: monad.bind_option_def fun_eq_iff split: option.split)


Input:
lemma replace_basis_completely :
  "\<lbrakk> set vs \<subseteq> V; lin_independent vs; length us = length vs;
        set us \<subseteq> Span vs; lin_independent us \<rbrakk> \<Longrightarrow> basis_for (Span vs) us"

Output:
using replace_basis[of vs us]
by auto


Input: lemma map_converter_id14: "map_converter id b out id res = map_converter' b out res"

Output: by(coinduction arbitrary: res) (auto 4 3 intro!: rel_funI simp add: converter.map_sel gpv.rel_map map_gpv_conv_map_gpv'[symmetric] intro!: gpv.rel_refl_strong)


Input: lemma test_bremdup1_refine_aux: "(test_bremdup1, my_bremdup_impl_loc.test_remdup) \<in> [my_bremdup_impl_loc]\<^sub>a nat_assn\<^sup>k \<rightarrow> nat_assn"

Output:
using test_bremdup1.refine unfolding hfref_def hn_refine_def
by (auto simp: pure_def)


Input: lemma s1619: "\<not> scf R16 \<succ>[Fishb(R19 A1)] scf R19"

Output: by (intro strategyproof'[where j = A1]) (simp_all add: insert_commute R16.eval R19.eval)


Input: lemma invariant_in_dom [simp]: "callee_invariant oracle (\<lambda>\<sigma>. x \<in> dom \<sigma>)"

Output: by unfold_locales(simp_all add: oracle_def split: option.split_asm)


Input:
lemma conv_callee_plus_id_right: "converter_of_callee (plus_intercept callee id_oracle) s =
  parallel_converter (converter_of_callee callee s) id_converter"

Output: by (coinduction arbitrary: callee s) (clarsimp split!: sum.split intro!: rel_funI , (force intro: gpv.rel_refl | simp add: gpv.rel_map id_oracle_def)+)


Input: lemma CCFix_nonrec_eqvt[eqvt]: "\<pi> \<bullet> (CoCallArityAnalysis.CCfix_nonrec cccExp x e) = CoCallArityAnalysis.CCfix_nonrec (\<pi> \<bullet> cccExp) (\<pi> \<bullet> x) (\<pi> \<bullet> e)"

Output:
apply (rule cfun_eqvtI) unfolding CoCallArityAnalysis.CCfix_nonrec_eq
by perm_simp rule


Input: lemma group_law_group: "group_law inverse neutral mult"

Output:
unfolding group_law_def
using group_class.axioms monoidl_law_monoidl unfolding class.group_axioms_def
by simp


Input:
lemma value_subst_value:
  assumes "value e" "value e'"
  shows   "value (e[e' / x])"

Output:
using assms
by (induct e e' x rule: subst_term.induct) auto


Input:
lemma modI_numeral_numeral [simp]:
  "mod\<cdot>(numeral i)\<cdot>(numeral j) = MkI' (Rings.modulo (numeral i) (numeral j))"

Output:
unfolding numeral_Integer_eq mod_Integer_def MkI'_def
by simp


Input: lemma den_eq_chop_num: "den = tree_chop num"

Output: by(coinduction rule: tree.coinduct_strong) simp


Input:
lemma gen_dfs_outer_initial:
  assumes "finite (E\<^sup>*``V0)"
  shows "gen_dfs_outer E (E\<^sup>*``V0) V0 V0 {} brk"

Output:
using assms unfolding gen_dfs_outer_def
by (auto intro: rev_ImageI)


Input:
lemma cupcake_v_update_preserve:
  assumes "is_cupcake_all_env env" "is_cupcake_ns (f (sem_env.v env))"
  shows "is_cupcake_all_env (sem_env.update_v f env)"

Output:
using assms
by (metis is_cupcake_all_env.simps(1) is_cupcake_all_envE is_cupcake_nsE sem_env.collapse sem_env.record_simps(1) sem_env.record_simps(2) sem_env.sel(2))


Input:
lemma (in encoding) indRelTEQ_impl_TRel_is_weak_reduction_coupled_simulation:
  fixes TRel :: "('procT \<times> 'procT) set"
  assumes couSim: "weak_reduction_coupled_simulation (indRelTEQ TRel) (STCal Source Target)"
  shows "weak_reduction_coupled_simulation (TRel\<^sup>*) Target"

Output:
using couSim weak_reduction_coupled_simulation_versus_simulation_and_contrasimulation refl indRelTEQ_impl_TRel_is_weak_reduction_simulation[where TRel="TRel"] indRelTEQ_impl_TRel_is_weak_reduction_contrasimulation[where TRel="TRel"]
by blast


Input:
lemma fields_Base [simp]:
"DeclConcepts.fields tprg Base
  = [((arr,Base), \<lparr>access=Public,static=True ,type=PrimT Boolean.[]\<rparr>),
     ((vee,Base), \<lparr>access=Public,static=False,type=Iface HasFoo    \<rparr>)]"

Output:
apply (subst fields_rec')
apply (auto simp add: BaseCl_def) done


Input: lemma att_orD1: " \<turnstile>(x1 # x2 \<oplus>\<^sub>\<or>\<^bsup>x\<^esup>) \<Longrightarrow> \<turnstile> x1"

Output: by (case_tac x2, (subst (asm) att_or, simp)+)


Input:
lemma make_invar_thm: "is_invar I \<Longrightarrow> I s"
    \<comment> \<open>Lemma to transfer an invariant into this locale\<close>

Output: using rwof_cons[OF _ rwof, folded is_invar_def] .


Input:
lemma inst_cswitch_independent_of_state:
  assumes "rcurrent s = rcurrent t"
  shows "rcurrent (rcswitch n s) = rcurrent (rcswitch n t)"

Output:
using rstate_invariant cswitch_preserves_invariants unfolding rcurrent_def rcswitch_def
by simp


Input:
lemma amd2_delete_refine:
    "(uncurry (amd_delete dflt), uncurry (RETURN oo (amd1_delete dflt)))
    \<in> id_assn\<^sup>k*\<^sub>a(is_nff dflt)\<^sup>d \<rightarrow>\<^sub>a is_nff dflt"

Output: by (sep_auto simp: amd_delete_def)


Input:
lemma subst_freshen_conclusions[simp]:
    assumes "pf \<in> set conclusions"
    shows "subst s (freshen a pf) = pf "

Output:
using assms conclusions_closed
by (simp add: closed_no_lconsts freshen_def rename_closed subst_closed)


Input:
lemma wadjust_on_left_moving_B_Bk1[simp]: "wadjust_on_left_moving_B m rs
                 (Oc # Oc # Oc\<up>(rs) @ Bk # Oc # Oc\<up>(m), [Bk])"

Output: apply(simp add: wadjust_on_left_moving_B.simps, auto) done


Input: lemma CD4a: "Der_1a \<D> \<Longrightarrow> Der_4e \<D> \<Longrightarrow> Cl_4 (\<C>\<^sub>D \<D>)"

Output:
unfolding Cl_der_def
by (smt ADDI_a_def Der_4e_def IDEM_def join_def)


Input:
theorem wls_freshEnv_swapEnv_exchange1:
assumes "wlsEnv rho"
shows "freshEnv xs x2 (rho &[x1 \<and> x2]_xs) = freshEnv xs x1 rho"

Output:
using assms
by (intro freshEnv_swapEnv_exchange1) auto


Input:
lemma stone_phi_complement:
  "complement (stone_phi (Abs_regular (-x))) (stone_phi (Abs_regular (--x)))"

Output: by (metis (mono_tags, lifting) eq_onp_same_args stone_phi.phi_complemented uminus_regular.abs_eq)


Input:
lemma cUNION_parametric [transfer_rule]: includes lifting_syntax shows
  "(rel_cset A ===> (A ===> rel_cset B) ===> rel_cset B) cUNION cUNION"

Output:
unfolding rel_fun_def
by transfer(blast intro: rel_set_UNION)


Input: lemma lossless_S1: "lossless_spmf (S1 msgs ())"

Output: by(simp add: S1_def local.etp.lossless_I split_def etp.lossless_S)


Input: lemma weight_sample_uniform_0 [simp]: "weight_spmf (sample_uniform 0) = 0"

Output: by(auto simp add: weight_sample_uniform indicator_def)


Input:
lemma M_simps:
  "edge_succ M = lists_succ xss"

Output:
unfolding to_map_def
by (cases G_list) auto


Input:
lemma sorted_list_subset_fusion_code:
  "sorted_list_subset_fusion eq g1 g2 s1 s2 =
  (if list.has_next g1 s1 then
     let (x, s1') = list.next g1 s1
     in list.has_next g2 s2 \<and> (
        let (y, s2') = list.next g2 s2
        in if eq x y then sorted_list_subset_fusion eq g1 g2 s1' s2'
           else y < x \<and> sorted_list_subset_fusion eq g1 g2 s1 s2')
   else True)"

Output:
unfolding sorted_list_subset_fusion_def
by(subst (1 2 5) list.unfoldr.simps)(simp add: split_beta Let_def)


Input: lemma erfc_at_top [tendsto_intros]: "((erfc :: real \<Rightarrow> real) \<longlongrightarrow> 0) at_top"

Output:
unfolding erfc_def [abs_def]
by (auto intro!: tendsto_eq_intros)


Input:
lemma get_ancestors_si_ptr:
  assumes "h \<turnstile> get_ancestors_si ptr \<rightarrow>\<^sub>r ancestors"
  shows "ptr \<in> set ancestors"

Output:
using assms
by(simp add: get_ancestors_si_def) (auto elim!: bind_returns_result_E2 split: option.splits intro!: bind_pure_I)


Input: lemma link_size[simp]: "size (link hp) = size hp"

Output: by (cases hp rule: link.cases) simp_all


Input: lemma uminus_sum_list: "- sum_list as = sum_list (map uminus (rev as))"

Output: by (induct as) (auto simp add: minus_add)


Input: lemma F_Un_D_subset: "(F \<union> D) \<subseteq> A"

Output: by (intro Un_least subset_trans [OF F_subset] subset_trans [OF D_subset]) (auto simp: A_def)


Input:
lemma finite_strict_prefix_set:
  shows "finite {xa. strict_prefix xa (x::'a list)}"

Output:
apply (induct x rule:rev_induct, simp)
apply (subgoal_tac "{xa. strict_prefix xa (xs @ [x])} = {xa. strict_prefix xa xs} \<union> {xs}")
by (auto simp:strict_prefix_def)


Input: lemma complex_norm_eq_1_exp: "norm z = 1 \<longleftrightarrow> exp(\<i> * of_real (Arg2pi z)) = z"

Output: by (metis Arg2pi_eq cis_conv_exp mult.left_neutral norm_cis of_real_1)


Input: lemma ab_semigroup_add_ow: "class.ab_semigroup_add = ab_semigroup_add_ow UNIV"

Output:
unfolding class.ab_semigroup_add_def ab_semigroup_add_ow_def class.ab_semigroup_add_axioms_def ab_semigroup_add_ow_axioms_def semigroup_add_ow
by simp


Input: lemma inl_invertible: "inl op xs = Some opinl \<Longrightarrow> deinl opinl = op"

Output: by (induction op xs rule: inl.induct; simp)


Input: lemma Rep_formula_top: "Rep_formula \<top> = UNIV"

Output:
unfolding top_formula_def
by (intro Abs_formula_inverse fba_UNIV)


Input:
lemma is_functor:
    shows "functor Cop.comp S map"

Output:
apply (unfold_locales)
using map_def arr_map map_preserves_dom map_preserves_cod map_preserves_comp
by auto


Input:
lemma per_init_per[simp, intro!]:
    "part_equiv (per_init D)"

Output:
unfolding per_init_def
by (auto simp: part_equiv_def sym_def trans_def)


Input: lemma R23 [simp]: "pmf (sds R23) b = 0" "pmf (sds R23) c = 0" "pmf (sds R23) d = 1 - pmf (sds R23) a"

Output:
using R23_R19.strategyproofness(1) lottery_conditions[OF R23.wf] R23.support
by (auto simp del: pmf_nonneg)


Input: lemma subst_cls_poss[simp]: "(poss AA) \<cdot> \<sigma> = poss (AA \<cdot>am \<sigma>)"

Output:
unfolding subst_cls_def subst_lit_def subst_atm_mset_def
by auto


Input: lemma trans_Sbis: "trans Sbis"

Output: by (metis Sbis_def Sretr_sym Sretr_sym_trans mono_Retr sym_trans_gfp)


Input:
lemma new_element_get_child_nodes_is_l_new_element_get_child_nodes [instances]:
  "l_new_element_get_child_nodes type_wf known_ptr get_child_nodes get_child_nodes_locs"

Output:
using new_element_is_l_new_element get_child_nodes_is_l_get_child_nodes
apply(auto simp add: l_new_element_get_child_nodes_def l_new_element_get_child_nodes_axioms_def)[1]
using get_child_nodes_new_element new_element_no_child_nodes
by fast+


Input: lemma Scons_not_Atom [iff]: "Scons M N \<noteq> Atom(a)"

Output:
unfolding Atom_def Scons_def Push_Node_def One_nat_def
by (blast intro: Node_K0_I Rep_Node [THEN Node_Push_I] dest!: Abs_Node_inj elim!: apfst_convE sym [THEN Push_neq_K0])


Input: lemma chart_eucl_in_atlas[intro,simp]: "chart_eucl \<in> manifold_eucl.atlas k"

Output:
using manifold_eucl.charts_subset_atlas
by auto


Input:
lemma venv_approx_trans[trans]:
  fixes ve1 ve2 ve3 :: "'c \<avenv>"
  shows "\<lbrakk> ve1 \<lessapprox> ve2; ve2 \<lessapprox> ve3 \<rbrakk> \<Longrightarrow> (ve1 \<lessapprox> ve3)"

Output:
unfolding venv_approx_def
by (rule smap_less_trans)


Input:
lemma pre_post_zero_top:
  "bot\<stileturn>-q = bot"

Output:
using bot_least order.eq_iff pre_post_galois tests_dual.sba_dual.sub_bot_def
by blast


Input: lemma lsu_one: "\<nu>\<^sup>\<natural> 1 \<le> (1::'a::unital_quantale)"

Output:
unfolding lsu_def
using bres_canc1 dual_order.trans le_top
by blast


Input:
lemma P1_real_ideal_DDH_advantage_False:
  assumes "\<sigma> = False"
  shows "mal_def.adv_P1 M \<sigma> z (P1_S1, P1_S2) \<A> D = ddh.DDH_advantage (P1_DDH_mal_adv_\<sigma>_False M z \<A> D)"

Output: by(simp add: P1_adv_real_ideal_model_def ddh.DDH_advantage_def P1_ideal_ddh1_\<sigma>_False P1_real_ddh0_\<sigma>_False assms P1_advantages_eq)


Input: lemma interp_subseteq_INTERP: "interp C \<subseteq> INTERP"

Output:
unfolding interp_def INTERP_def
by (auto simp: production_unfold)


Input: lemma poly_rel_irreducible[transfer_rule]: "(poly_rel ===> (=)) (irreducible_i ops) irreducible\<^sub>d"

Output:
unfolding irreducible_i_def[abs_def] irreducible\<^sub>d_def[abs_def]
by (transfer_prover_start, transfer_step+, auto)


Input: lemma to_tree_order_is_l_to_tree_order [instances]: "l_to_tree_order to_tree_order"

Output:
using to_tree_order_pure l_to_tree_order_def
by blast


Input:
lemma tbisim_flip [flip_simps]:
  "FWbisimulation_base.tbisim (\<lambda>t. flip (bisim t)) (flip bisim_wait) w t ts2 m2 ts1 m1 =
   FWbisimulation_base.tbisim bisim bisim_wait w t ts1 m1 ts2 m2"

Output:
unfolding FWbisimulation_base.tbisim_def flip_simps
by auto


Input: lemma bigomega_const_iff [simp]: "(\<lambda>_. c1) \<in> \<Omega>[F](\<lambda>_. c2) \<longleftrightarrow> F = bot \<or> c1 \<noteq> 0 \<or> c2 = 0"

Output: by (cases "c1 = 0"; cases "c2 = 0") (auto simp: bigomega_def eventually_False mult_le_0_iff intro: exI[of _ 1] exI[of _ "norm c1 / norm c2"])


Input: lemma extensionalD_empty[simp]: "extensionalD d {} = {\<lambda>x. d}"

Output:
unfolding extensionalD_def
by (simp add: set_eq_iff fun_eq_iff)


Input:
lemma S_list_endomorphism:
  "ss\<in>lists S \<Longrightarrow> ChamberComplexEndomorphism X (permutation (sum_list ss))"

Output: by (induct ss) (auto simp add: zero_permutation.rep_eq trivial_endomorphism plus_permutation.rep_eq S_endomorphism ChamberComplexEndomorphism.endo_comp )


Input: lemma monotone_lzip: "monotone (rel_prod (\<sqsubseteq>) (\<sqsubseteq>)) (\<sqsubseteq>) (case_prod lzip)"

Output: by(rule llist.fixp_preserves_mono2[OF lzip_mono lzip_conv_fixp]) simp


Input:
lemma (in sys) mut_handshake_invL[intro]:
  notes if_splits[split]
  notes fun_upd_apply[simp]
  shows
  "\<lbrace> mut_m.handshake_invL m \<rbrace> sys"

Output: by (vcg_chainsaw mut_m.handshake_invL_def)


Input:
lemma lookup_phis'_codem_next:
  assumes "\<And>ns. Mapping.lookup nodes_of_phis (snd next) = Some ns \<Longrightarrow> finite ns"
  shows "Mapping.lookup (phis'_codem g next next' nodes_of_phis) next = None"

Output:
using assms unfolding phis'_codem_def
by (auto simp: Set.remove_def lookup_delete split: option.splits)


Input:
lemma ta_bisim_mono:
  assumes major: "ta_bisim bisim ta1 ta2"
  and mono: "\<And>t s1 s2. bisim t s1 s2 \<Longrightarrow> bisim' t s1 s2"
  shows "ta_bisim bisim' ta1 ta2"

Output:
using major
by(auto simp add: ta_bisim_def elim!: List.list_all2_mono nta_bisim_mono intro: mono)


Input:
lemma invar_initial:
    "\<lbrakk>outer_invar it D0; v0\<in>it; v0\<notin>D0\<rbrakk> \<Longrightarrow> invar v0 D0 (initial v0 D0)"

Output:
unfolding outer_invar_def
apply (drule outer_invar_loc.invar_initial_aux)
by auto


Input:
lemma resource_of_obsf_oracle_Fault [simp]:
  "resource_of_oracle (obsf_oracle oracle) Fault = const_resource Fault"

Output: by(coinduction)(auto simp add: rel_fun_def)


Input:
lemma app_iso_inv[simp]:
  assumes "digraph_isomorphism hom"
  shows "app_iso (inv_iso hom) (app_iso hom G) = G"

Output:
using assms
by (intro pre_digraph.equality) (auto intro: rev_image_eqI)


Input:
lemma ccw'_sortedP_polychain_of2:
  assumes "ccw'.sortedP 0 [u, v]"
  shows "ccw'.sortedP x0 (map snd (polychain_of x0 [u, v]))"

Output:
using assms
by (auto intro!: linorder_list0.sortedP.Nil linorder_list0.sortedP.Cons elim!: linorder_list0.sortedP_Cons simp: ac_simps ccw'.translate_origin)


Input:
lemma list_of_dlist_eq_singleton_conv:
  "list_of_dlist dxs = [x] \<longleftrightarrow> dxs = DList_Set.insert x DList_Set.empty"

Output: by transfer(case_tac dxs, auto simp add: equal_base.list_insert_def)


Input:
lemma orbit_cycle_elem:
  assumes "distinct as" and "a \<in> set as"
  shows "orbit \<langle>as\<rangle> a = set as"

Output: oops \<comment> \<open>(we need rotation here\<close>


Input: lemma permutation_edge_pred: "permutation (edge_pred M)"

Output: by (metis edge_pred_permutes finite_arcs permutation_permutes)


Input: lemma ennreal_inverse_top[simp]: "inverse top = (0::ennreal)"

Output: by transfer (simp add: top_ereal_def ereal_inverse_eq_0)


Input: lemma "continuous_on UNIV stereographic"

Output:
unfolding continuous_on_iff unfolding dist_complex_homo_def dist_riemann_sphere_def
by (subst dist_stereographic', auto)


Input:
lemma recvcap_preserves_InvCapsNonneg:
  assumes "InvCapsNonneg c0"
    and   "next_recvcap' c0 c1 p t"
  shows   "InvCapsNonneg c1"

Output:
using assms unfolding InvCapsNonneg_def next_recvcap'_def
by simp


Input:
lemma gmd_correct:
  assumes "is_measured_digit d"
  shows "gmd d = sum_list (map snd (digitToList d))"

Output: by (insert assms, cases d, auto simp add: gmn_correct add.assoc)


Input:
lemma col_space_eq_row_space_transpose:
  shows "col_space A = row_space A\<^sup>T"

Output: unfolding col_space_def row_space_def Matrix.rows_transpose ..


Input:
lemma (in strategic_space_2p) coop_is_pareto_opt:
  assumes "alice_payoff = 3 \<and> bob_payoff = 3"
  shows "is_pareto_opt"

Output:
using is_pareto_opt_def strategic_space_2p.sum_payoff_le_6 assms
by fastforce


Input: lemma block_size_lt_v: "\<k> \<le> \<v>"

Output:
using v_non_zero block_size_lt_v design_blocks_nempty uniform
by auto


Input:
lemma get_attribute_is_l_get_attribute [instances]:
  "l_get_attribute type_wf get_attribute get_attribute_locs"

Output:
apply(unfold_locales)
using get_attribute_reads get_attribute_ok get_attribute_ptr_in_heap get_attribute_pure
by blast+


Input:
lemma range_prefix_match_sm[simp]:  "wordinterval_to_set (fst (range_prefix_match pfx rg)) =
    fst (ipset_prefix_match pfx (wordinterval_to_set rg))"

Output: by (metis fst_conv ipset_prefix_match_m wordinterval_intersection_set_eq prefix_to_wordinterval_set_eq range_prefix_match_def)


Input:
lemma cupcake_list_complete:
  "evaluate_list (evaluate env) s1 es res \<Longrightarrow>
    is_cupcake_all_env env \<Longrightarrow> list_all is_cupcake_exp es  \<Longrightarrow>  \<exists>rs. list_all2_shortcircuit (cupcake_evaluate_single env) es rs \<and> sequence_result rs = (snd res)"

Output: by (fastforce intro:cupcake_list_complete0 cupcake_single_complete evaluate_list_mono_strong)


Input: lemma splitAt_simpD'[simp]: "\<And> a. a \<noteq> ram \<Longrightarrow> snd (splitAt ram (a # b)) = snd (splitAt ram b)"

Output:
apply (rule splitAt_simpD)
by auto


Input:
lemma non_trivial_combine_imp_dependent:
  assumes "set Ks \<subseteq> K" and "combine Ks Us = \<zero>" and "\<not> set (take (length Us) Ks) \<subseteq> { \<zero> }"
  shows "dependent K Us"

Output:
using independent_imp_trivial_combine[OF _ assms(1-2)] assms(3)
by blast


Input:
lemma isovarspar_sum:
  "isolate_variable_sparse (p+q) var deg =
  isolate_variable_sparse (p) var deg
  + isolate_variable_sparse (q) var deg"

Output:
apply (auto simp add: mpoly_eq_iff coeff_isolate_variable_sparse )
apply (metis More_MPoly_Type.coeff_add coeff_isolate_variable_sparse)
by (metis More_MPoly_Type.coeff_add add.comm_neutral coeff_isolate_variable_sparse less_numeral_extra(3))


Input:
theorem Hset1_bd: "|Hset1 (x :: ('p1, 'p2, 'p3, 'p, 'a1, 'a2) H )| \<le>o
  (Hbd :: ('p1, 'p2, 'p3, 'p) Hbd_type rel)"

Output: by (tactic \<open>BNF_Comp_Tactics.mk_comp_set_bd_tac @{context} @{thm refl} NONE @{thm Hset1_alt} @{thms comp_single_set_bd[OF F1.bd_Card_order F1.set_bd(1) G.set_bd(1)] comp_single_set_bd[OF F2.bd_Card_order F2.set_bd(1) G.set_bd(2)] comp_single_set_bd[OF F3.bd_Card_order F3.set_bd(1) G.set_bd(3)]}\<close>)


Input: lemma finite_calM: "finite calM"

Output:
unfolding calM_def
by (rule finite_subset [where B = "Pow (carrier G)"]) auto


Input: lemma is_longest_prefix_routing_sort: "is_longest_prefix_routing (sort_rtbl r)"

Output:
unfolding sort_rtbl_def is_longest_prefix_routing_def
by simp


Input:
lemma SV_inv3_inductive:
  "init sv_TS \<subseteq> SV_inv3"
  "{SV_inv3} trans sv_TS {> SV_inv3}"

Output:
apply (simp add: sv_TS_defs SV_inv3_def)
by (auto simp add: sv_TS_defs SV_inv3_event_pres)


Input:
lemma d0_omega_mult:
  "d(x\<^sup>\<omega> * y * bot) = d(x\<^sup>\<omega> * bot)"

Output:
apply (rule order.antisym)
apply (simp add: d_isotone mult_isotone omega_sub_vector)
by (metis d_isotone mult_assoc mult_right_isotone bot_least)


Input: lemma pincAB: "Fr_2 \<F> \<Longrightarrow> \<bullet>\<^sup>AA \<^bold>\<approx> \<bullet>\<^sup>BA"

Output:
using Br_fr_def Cl_fr_def pF2 conn
by auto


Input:
lemma (in CRR_market) delta_pf_portfolio:
  shows "portfolio (delta_pf N der matur)"

Output:
unfolding delta_pf_def
by (simp add: single_comp_portfolio)


Input:
lemma (in complete_lattice) lattice_partial_function_definition:
  "partial_function_definitions (\<le>) Sup"

Output: by(unfold_locales)(auto intro: Sup_upper Sup_least)


Input:
lemma exec1_drop_suffix_aux:
"(cs12,s) \<rightarrow> (cs1'2,s') \<Longrightarrow> \<forall>cs1 cs2 cs1'.
 cs12 = cs1@cs2 & cs1'2 = cs1'@cs2 & cs1 \<noteq> [] \<longrightarrow> (cs1,s) \<rightarrow> (cs1',s')"

Output:
apply(erule exec1.induct)
apply (force intro:exec1.intros simp add: neq_Nil_conv)+ done


Input:
lemma wd_hide_prize:
  "well_def hide_prize"

Output:
unfolding hide_prize_def hide_behind_def
by(simp add:wd_intros)


Input: lemma asIMOD_wlsFSwSb: "wlsSEM SEM \<Longrightarrow> iwlsFSwSb (asIMOD SEM)"

Output:
unfolding iwlsFSwSb_def
using asIMOD_wlsFSw asIMOD_igSubstAllIPresIGWlsAll asIMOD_igSubstCls
by auto


Input:
lemma nlistToTree_inv:
  "\<forall> x \<in> set nl. is_measured_node x \<Longrightarrow> is_measured_ftree (nlistToTree nl)"
  "\<forall> x \<in> set nl. is_leveln_node n x \<Longrightarrow> is_leveln_ftree n (nlistToTree nl)"

Output: by (unfold nlistToTree_def, induct nl, auto simp add: nlcons_invmeas) (induct nl, auto simp add: nlcons_invlevel)


Input:
lemma cfinite_dim_finite_subspace_basis:
  assumes \<open>csubspace X\<close>
  shows "\<exists>basis::'a::cfinite_dim set. finite basis \<and> cindependent basis \<and> cspan basis = X"

Output: by (meson assms cindependent_cfinite_dim_finite complex_vector.basis_exists complex_vector.span_subspace)


Input:
lemma bind_option_gpv_transfer [transfer_rule]:
  "(cr_option_le_gpv ===> ((=) ===> cr_option_le_gpv) ===> cr_option_le_gpv) Option.bind bind_gpv"

Output:
apply(clarsimp simp add: cr_option_le_gpv_def rel_fun_def bind_eq_Some_conv) subgoal for f g x y
by(erule allE[where x=y]) auto done


Input:
lemma finite_two_chain_horizontal_boundary:
  assumes "finite two_chain"
  shows "finite (two_chain_horizontal_boundary two_chain)"

Output:
using assms
by (simp add: two_chain_horizontal_boundary_def horizontal_boundary_def)


Input: lemma iffb_surj: "surj fb\<^sup>-\<^sub>\<F>"

Output:
using surj_def
by (metis comp_apply iffb_inv1 surj_id)


Input:
lemma Conj_eq_iff [simp]:
  assumes "finite (supp xset1)" and "finite (supp xset2)"
  shows "Conj xset1 = Conj xset2 \<longleftrightarrow> xset1 = xset2"

Output:
using assms
by (metis (erased, hide_lams) Conj\<^sub>\<alpha>_eq_iff Conj_rep_eq Rep_formula_inverse injI inj_eq bset.inj_map)


Input: lemma fin_dim[simp]: "fin_dim"

Output:
unfolding fin_dim_def
apply (intro eqTrueI exI conjI)
using span_unit_vecs_is_carrier unit_vecs_carrier
by auto


Input:
lemma prec_first_EV_SIGNAL_action:
assumes "is_SK_EV_SIGNAL aseq"
  shows "rprecondition s d (hd aseq)"

Output:
using assms unfolding is_SK_EV_SIGNAL_def rprecondition_def atomic_step_precondition_def ev_signal_precondition_def
by auto


Input:
lemma fun_chain_at_top_at_top:
  assumes "filterlim (f :: ('a::order) \<Rightarrow> 'a) at_top at_top"
  shows   "filterlim (f ^^ n) at_top at_top"

Output: by (induction n) (auto intro: filterlim_ident filterlim_compose[OF assms])


Input: lemma bal_i1: "bal_i 1 1"

Output:
using bal_i_balance[of "Node Leaf undefined Leaf"]
by(auto simp add: balance_tree_def Balance.bal_tree_def Balance.bal_list_def Balance.bal_simps)


Input: lemma inverse_ereal_tendsto_at_right_0: "(inverse \<longlongrightarrow> \<infinity>) (at_right (0::ereal))"

Output:
unfolding tendsto_compose_filtermap[symmetric] at_right_ereal zero_ereal_def
by (subst filterlim_cong[OF refl refl, where g="\<lambda>x. ereal (inverse x)"]) (auto simp: eventually_at_filter tendsto_PInfty_eq_at_top filterlim_inverse_at_top_right)


Input:
lemma pmf_of_alist_aux:
  assumes "(s, \<mu>) \<in> set K"
  shows
    "pmf (pmf_of_alist \<mu>) t = (case map_of \<mu> t of
      None \<Rightarrow> 0
    | Some p \<Rightarrow> p)"

Output:
using assms is_pmf unfolding pmf_of_alist_def
by (intro pmf_embed_pmf pmf_of_alist_support_aux_2) (auto 4 3 split: option.split dest: map_of_SomeD)


Input:
lemma transpose_mult_matrix:
  assumes
  "\<forall>a. fmul 0 a = 0"
  "\<forall>a. fmul a 0 = 0"
  "fadd 0 0 = 0"
  "\<forall>x y. fmul y x = fmul x y"
  shows
  "transpose_matrix (mult_matrix fmul fadd A B) = mult_matrix fmul fadd (transpose_matrix B) (transpose_matrix A)"

Output:
apply (simp add: Rep_matrix_inject[THEN sym])
apply (rule ext)+
using assms
apply (simp add: Rep_mult_matrix ac_simps) done


Input:
lemma max_Var_floatarith_fold_const_fa:
  "max_Var_floatarith (fold_const_fa fa) \<le> max_Var_floatarith fa"

Output: by (induction fa) (auto simp: fold_const_fa.simps split!: option.splits floatarith.splits)


Input: theorem phis'_pruned: "braun_ssa.pruned g"

Output:
unfolding braun_ssa.pruned_def braun_ssa.phiDefs_def
apply (subst phis'_def)
by (auto split:prod.splits if_split_asm simp add:phiDefNodes_def elim!:fold_union_elem phiDefNodes_aux_pruned)


Input: lemma T_on_rand_as_sum: "T_on_rand A s0 rs = sum (T_on_rand_n A s0 rs) {..<length rs} "

Output:
apply(induct rs rule: rev_induct)
by(simp_all add: T_on_rand'_append nth_append)


Input:
lemma cr_option_gpv_conv_OO:
  "cr_option_gpv = cr_spmf_option\<inverse>\<inverse> OO cr_spmf_gpv"

Output: by(simp add: fun_eq_iff relcompp.simps cr_option_gpv_def cr_spmf_gpv_def cr_spmf_option_def)


Input:
lemma scast_scast_a:
  "\<lbrakk> is_down (scast :: 'b word \<Rightarrow> 'c word) \<rbrakk> \<Longrightarrow>
            (scast (scast (a :: 'a::len word) :: 'b::len word) :: 'c::len word) = scast a"

Output:
apply (simp only: scast_eq)
apply (metis down_cast_same is_up_down scast_eq ucast_down_wi) done


Input: lemma lim_h_minus_le_lim_h_plus: "lim_h_minus e \<le> lim_h_plus e"

Output: by(rule SUP_mono)(blast intro: h_minus_le_h_plus)


Input: lemma filter_IFS_no_violations_accu_distinct: "\<lbrakk> distinct (Es@accu) \<rbrakk> \<Longrightarrow> distinct (filter_IFS_no_violations_accu G M accu Es)"

Output:
apply(induction Es arbitrary: accu)
by(simp_all)


Input:
lemma init_state_present2:
  assumes
    "execute (init_state k1 k2) heap = Some ((k_ref1, k_ref2, m_ref1, m_ref2), heap')"
  shows
    "Array.present heap' (Ref.get heap' m_ref1)" "Array.present heap' (Ref.get heap' m_ref2)"

Output:
using assms unfolding init_state_def
by (auto 4 3 simp: execute_simps init_state_inner_alloc elim!: execute_bind_success'[OF success_empty] dest: inite_state_inner_present' empty_present empty_present' )


Input: lemma HomFtorContraCod: "CatCod (Hom\<^bsub>C\<^esub>[\<midarrow>,X]) = SET"

Output: by(simp add: HomFtorContra_def HomFtorContra'_def MakeFtor_def)


Input:
lemma set_case_simps [simp] :
  "set_case {} c_empty c_sing c_else = c_empty"
  "set_case {x} c_empty c_sing c_else = c_sing x"
  "card s > 1 \<Longrightarrow> set_case s c_empty c_sing c_else = c_else"
  "\<not>(finite s) \<Longrightarrow> set_case s c_empty c_sing c_else = c_else"

Output:
unfolding set_case_def
by auto


Input: lemma coeffs_of_int_poly: "coeffs (of_int_poly (Mp x) :: 'a mod_ring poly) = map of_int (coeffs (Mp x))"

Output:
apply (rule coeffs_map_poly)
by (metis M_0 M_M Mp_coeff leading_coeff_0_iff of_int_hom.hom_zero to_int_mod_ring_of_int_M)


Input:
lemma rwof_step:
    "\<lbrakk> nofail (m0 \<bind> WHILE cond step); rwof m0 cond step s; cond s \<rbrakk>
    \<Longrightarrow> step s \<le> SPEC (rwof m0 cond step)"

Output:
using pw_rwof_step[of m0 cond step s]
by (simp add: pw_le_iff refine_pw_simps)


Input:
lemma get_attribute_reads:
  "reads (get_attribute_locs element_ptr) (get_attribute element_ptr k) h h'"

Output: by(auto simp add: get_attribute_impl[unfolded a_get_attribute_def] get_attribute_locs_impl[unfolded a_get_attribute_locs_def] reads_insert_writes_set_right intro!: reads_bind_pure)


Input: lemma strict3[simp,code_unfold]: " f None y = invalid"

Output: by(rule ext, simp add: def_scheme' True_def False_def)


Input:
lemma node_ptr_kinds_commutes [simp]:
  "cast node_ptr |\<in>| object_ptr_kinds h \<longleftrightarrow> node_ptr |\<in>| node_ptr_kinds h"

Output:
apply(auto simp add: node_ptr_kinds_def split: option.splits)[1]
by (metis (no_types, lifting) ffmember_filter fimage_eqI fset.map_comp is_node_ptr_kind_none node_ptr_casts_commute2 option.distinct(1) option.sel)


Input: lemma valid7[simp]: "\<upsilon> (X \<triangleq> Y) = True"

Output: by(rule ext, auto simp: valid_def True_def False_def StrongEq_def bot_fun_def bot_option_def None_option_def None_fun_def)


Input:
lemma is_msg_inv_ip [simp]:
  "\<xi>' \<in> is_rerr \<xi>   \<Longrightarrow> ip \<xi>' = ip \<xi>"
  "\<xi>' \<in> is_rrep \<xi>   \<Longrightarrow> ip \<xi>' = ip \<xi>"
  "\<xi>' \<in> is_rreq \<xi>   \<Longrightarrow> ip \<xi>' = ip \<xi>"
  "\<xi>' \<in> is_pkt \<xi>    \<Longrightarrow> ip \<xi>' = ip \<xi>"
  "\<xi>' \<in> is_newpkt \<xi> \<Longrightarrow> ip \<xi>' = ip \<xi>"

Output:
unfolding is_msg_defs
by (cases "msg \<xi>", clarsimp+)+


Input: lemma web_flow_iff: "web_flow \<Gamma> f \<longleftrightarrow> current \<Gamma> f"

Output:
using bipartite_V
by(auto simp add: web_flow.simps)


Input:
lemma effective_tensor_compose_distribution2:"matrix_match A1 A2 B1 B2 \<Longrightarrow>
   mat ((row_length A1)*(row_length B1))
            ((length A2)*(length B2))
                    ((A1 \<otimes> B1) \<circ>(A2 \<otimes>B2))"

Output:
using tensor_compose_distribution2 unfolding matrix_match_def
by auto


Input: lemma (in lbv) top_le_conv [simp]: "\<top> \<sqsubseteq>\<^sub>r x = (x = \<top>)"

Output: by (insert semilat) (simp add: top top_le_conv)


Input:
lemma GroupByPresentationInducedFun_S_P_id:
  "GroupByPresentationInducedFun S P id"

Output: by ( intro_locales, rule GroupByPresentation_S_P, unfold_locales, rule freeliftid_trivial_P )


Input: lemma paval_extend:  "ps1 ## ps2 \<Longrightarrow> vars a \<subseteq> dom ps1 \<Longrightarrow> paval a (ps1 + ps2) = paval a ps1"

Output:
apply(induct a)
apply (auto simp: sep_disj_fun_def domain_conv)
by (metis domI map_add_comm map_add_dom_app_simps(1) option.sel plus_fun_conv)


Input:
lemma e2stack_stack [simp]:
  "e2stack (encode_config (ss, rv)) = list_encode (map encode_frame ss)"

Output:
unfolding e2stack_def
using encode_config
by simp


Input: lemma rGamma_series_nonpos_Ints_LIMSEQ: "z \<in> \<int>\<^sub>\<le>\<^sub>0 \<Longrightarrow> rGamma_series z \<longlonglongrightarrow> 0"

Output: by (elim nonpos_Ints_cases', hypsubst, subst tendsto_cong, rule rGamma_series_minus_of_nat, simp)


Input:
lemma parent_child_rel_node_ptr:
  "(parent, child) \<in> parent_child_rel h \<Longrightarrow> is_node_ptr_kind child"

Output: by(auto simp add: parent_child_rel_def)


Input:
lemma eval_eval_max: "\<lbrakk>s1 -e1\<succ>v1-    n1   \<rightarrow> t1 ; s2 -e2\<succ>v2-       n2\<rightarrow> t2\<rbrakk> \<Longrightarrow>
                       s1 -e1\<succ>v1-max n1 n2\<rightarrow> t1 \<and> s2 -e2\<succ>v2-max n1 n2\<rightarrow> t2"

Output: by (fast intro: eval_mono max.cobounded1 max.cobounded2)


Input:
lemma sin_cos_squared_add_cpx:
  "\<i>*complex_of_real (sin (\<gamma>/2)) * (\<i>*complex_of_real (sin (\<gamma>/2))) -
   complex_of_real (cos (\<gamma>/2)) * complex_of_real (cos (\<gamma>/2)) = -1"

Output:
apply (auto simp add: algebra_simps)
by (metis of_real_add of_real_hom.hom_one of_real_mult sin_cos_squared_add3)


Input:
lemma parallel_oracle_split_asm:
  "P (parallel_oracle s1s2 lr) \<longleftrightarrow>
  \<not> ((\<exists>s1 s2 x. s1s2 = (s1, s2) \<and> lr = Inl x \<and> \<not> P (map_spmf (map_prod Inl (\<lambda>s1'. (s1', s2))) (left s1 x))) \<or>
     (\<exists>s1 s2 y. s1s2 = (s1, s2) \<and> lr = Inr y \<and> \<not> P (map_spmf (map_prod Inr (Pair s1)) (right s2 y))))"

Output: by(cases s1s2; cases lr) auto


Input:
lemma get_ancestors_not_node:
  assumes "h \<turnstile> get_ancestors ptr \<rightarrow>\<^sub>r ancestors"
  assumes "\<not>is_node_ptr_kind ptr"
  shows "ancestors = [ptr]"

Output:
using assms
apply(simp add: get_ancestors_def)
by(auto elim!: bind_returns_result_E2 split: option.splits)


Input:
lemma Quotient3_tmap_Abs_Rep:
  "\<lbrakk>Quotient3 R1 Abs1 Rep1; Quotient3 R2 Abs2 Rep2\<rbrakk>
  \<Longrightarrow> tmap Abs1 Abs2 (tmap Rep1 Rep2 ts) = ts"

Output: by(drule abs_o_rep)+(simp add: tllist.map_comp tmap_id_id)


Input: lemma witness_weights:"witness_l rs = insert_weights shared_weights (deep_model_l rs) witness_weights"

Output: by (metis (full_types) insert_extract_weights_cong_shared insert_extract_weights_cong_unshared shared_weight_net_witness witness_is_deep_model witness_weights_def)


Input:
lemma exec_gpv_pauses:
  "exec_gpv callee (pauses xs) s =
   map_spmf (Pair ()) (foldl_spmf (map_fun id (map_fun id (map_spmf snd)) callee) (return_spmf s) xs)"

Output: by(induction xs arbitrary: s)(simp_all add: split_def foldl_spmf_Cons' map_bind_spmf bind_map_spmf o_def del: foldl_spmf_Cons)


Input:
theorem se_mono_for_sub :
  assumes "se c1 l c1'"
  assumes "se c2 l c2'"
  assumes "c2 \<sqsubseteq> c1"
  shows   "c2' \<sqsubseteq> c1'"

Output:
using assms
by ((cases l), (simp add : ), (simp add : states_of_se_assume subsums_def, blast), (simp add : states_of_se_assign subsums_def, blast))


Input:
lemma natural_transformation_\<alpha>:
    shows "natural_transformation VVV.comp vcomp HoHV HoVH \<alpha>\<^sub>S\<^sub>B"

Output:
using assoc_def \<alpha>.natural_transformation_axioms
by auto


Input:
lemma substInputChain[simp]:
  fixes xvec :: "name list"
  and   N    :: "'a"
  and   P    :: "('a, 'b, 'c) psi"
  and   yvec :: "name list"
  and   Tvec :: "'a list"

  assumes "xvec \<sharp>* yvec"
  and     "xvec \<sharp>* Tvec"

  shows "subs' (inputChain xvec N P) yvec Tvec = inputChain xvec (substTerm N yvec Tvec) (subs P yvec Tvec)"

Output:
using assms
by(induct xvec) (auto simp add: psi.inject)


Input:
lemma parse_nodes [intro]:
  "is_parser parse_nodes"

Output:
unfolding is_parser_def
using parse_nodes_help
by blast


Input:
lemma map_of_simp:
  "state_mem_defs.map_of lookup_trace = map_of o snd"

Output:
unfolding state_mem_defs.map_of_def lookup_trace_def
by (rule ext) (auto split: prod.split option.split)


Input: lemma wf_theory_imp_is_std_sig: "wf_theory \<Theta> \<Longrightarrow> is_std_sig (sig \<Theta>)"

Output: by (cases \<Theta> rule: theory_full_exhaust) simp


Input: lemma edges_less_eq_linorder: "is_linorder_rel edges_less_eq"

Output:
unfolding edges_less_eq_def is_linorder_rel_def
by (metis linear order_trans)


Input: lemma essential_\<E>: fixes \<Gamma> (structure) shows "essential \<Gamma> (B \<Gamma>) (\<E> S) = essential \<Gamma> (B \<Gamma>) S"

Output: by(subst essential_RF[symmetric])(simp only: RF_essential essential_RF)


Input:
lemma special_soundness:
  shows "\<Sigma>_OR.special_soundness"

Output:
unfolding \<Sigma>_OR.special_soundness_def
using ss prod.collapse
by fastforce


Input: lemma valid_plan_then_lookup_Some: "valid_plan \<pi>s \<Longrightarrow> (\<forall>\<pi> \<in> set \<pi>s. lookup_operator \<pi> \<noteq> None)"

Output:
using path_to_then_lookup_Some
by(simp add: valid_plan_def)


Input: lemma reachNT_reach: assumes "reachNT s"  shows "reach s"

Output:
using assms
by induct (auto intro: reach.intros, metis reach.Step snd_conv validTrans)


Input: lemma Infinitesimal_monad_eq: "e \<in> Infinitesimal \<Longrightarrow> monad (x + e) = monad x"

Output: by (fast intro!: Infinitesimal_add_approx_self [THEN approx_sym] approx_monad_iff [THEN iffD1])


Input: lemma init_no_adm_edges[simp]: "adm_edges pp_init_f pp_init_l = {}"

Output:
unfolding adm_edges_def pp_init_l_def
using card_V_ge2
by auto


Input:
lemma DN_in_hom [intro]:
    assumes "arr \<mu>"
    shows "\<guillemotleft>DN \<mu> : DN (src \<mu>) \<rightarrow>\<^sub>B DN (trg \<mu>)\<guillemotright>"
    and "\<guillemotleft>DN \<mu> : DN (dom \<mu>) \<Rightarrow>\<^sub>B DN (cod \<mu>)\<guillemotright>"

Output:
using assms DN_def arr_char [of \<mu>] B.vconn_implies_hpar(1-2) E.eval_in_hom(1) B.in_hhom_def
by auto


Input:
lemma init_atoms_equiv_bounds:
  "{} \<doteq> \<B> (init t)"

Output:
using init_bounds unfolding atoms_equiv_bounds.simps satisfies_bounds.simps in_bounds.simps satisfies_atom_set_def unfolding bound_compare_defs
by (auto simp: indexl_def indexu_def boundsl_def boundsu_def)


Input:
lemma inner_loop2_correct:
    assumes "(succl, succ) \<in> \<langle>Id\<rangle>list_set_rel"
    (*assumes "N \<subseteq> dom PRED"*)
    assumes [simplified, simp]:
      "(dsti,dst)\<in>Id" "(ui, u) \<in> Id" "(PREDi, PRED) \<in> Id" "(Ni, N) \<in> Id"
    shows "inner_loop2 dsti succl ui PREDi Ni
      \<le> \<Down> Id (add_succ_spec dst succ u PRED N)"

Output:
apply simp
apply (rule conc_trans[OF inner_loop2_refine inner_loop_refine, simplified])
using assms(1-2)
apply (simp_all) done


Input: lemma hom_inverse[hom_distribs]: "hom (inverse x) = inverse (hom x)"

Output: by (metis hom_mult hom_one hom_zero inverse_unique inverse_zero right_inverse)


Input:
lemma cong3_transitivity:
  assumes "A0 B0 C0 Cong3 A1 B1 C1" and
    "A1 B1 C1 Cong3 A2 B2 C2"
  shows "A0 B0 C0 Cong3 A2 B2 C2"

Output: by (meson assms(1) assms(2) Cong3_def cong_inner_transitivity not_cong_3412)


Input:
lemma lm012:
  "allAllocations N {} \<subseteq> {{}}"

Output:
using emptyset_part_emptyset3 rangeEmpty characterizationallAllocations mem_Collect_eq subsetI vimage_def
by metis


Input:
lemma satA_o:
"satA (int \<xi> o \<rho>) at = satA \<xi> (substA \<rho> at)"

Output: by (cases at, simp_all add: int_o_subst int_o[of \<xi> \<rho>])


Input: lemma HMA_V_add [transfer_rule]: "(HMA_V ===> HMA_V ===> HMA_V) (+) (+) "

Output:
unfolding rel_fun_def HMA_V_def
by (auto simp: from_hma\<^sub>v_add)


Input:
lemma set_mode_get_shadow_root_is_l_set_mode_get_shadow_root [instances]:
  "l_set_mode_get_shadow_root type_wf set_mode set_mode_locs get_shadow_root
                                         get_shadow_root_locs"

Output:
using set_mode_is_l_set_mode get_shadow_root_is_l_get_shadow_root
apply(simp add: l_set_mode_get_shadow_root_def l_set_mode_get_shadow_root_axioms_def)
using set_mode_get_shadow_root
by fast


Input: lemma measure_spmf_return_spmf: "measure_spmf (return_spmf x) = Giry_Monad.return (count_space UNIV) x"

Output: by(rule measure_eqI)(simp_all add: measure_spmf_def emeasure_distr space_restrict_space emeasure_restrict_space indicator_def)


Input:
lemma randomElLemma:
   assumes "set list \<noteq> {}"
   shows "randomEl list random \<in> set list"

Output:
using assms
by (simp add: randomEl_def)


Input:
lemma inverse_mat_base_case_2_R:
  shows "inverts_mat (mat_of_rows_list 3 [[1,1,1], [0,1,0], [1,0,-1]]::rat mat) (mat_of_rows_list 3  [[1/2, -1/2, 1/2], [0, 1, 0], [1/2, -1/2, -1/2]]:: rat mat)"

Output:
unfolding inverts_mat_def mat_of_rows_list_def mat_eq_iff
apply auto unfolding less_three
by (auto simp add: scalar_prod_def)


Input:
lemma g_1_lemma:
  fixes res :: "int \<times> int"
  assumes "0 \<le> fst res" "fst res < p" "0 \<le> snd res" "snd res < q"
  shows "P_1 res (g_1 res)"

Output:
using assms P_1_lemma [of res] theI' [of "P_1 res"] g_1_def
by auto


Input:
lemma epath_stl_smap_fst[simp]:
  "epath (smap fst stepSs) \<Longrightarrow>
   epath (smap fst (stl stepSs))"

Output: by (erule epath.cases) (auto simp del: stream.map_sel simp add: stream.map_sel[symmetric])


Input: lemma get_parent_reads: "reads get_parent_locs (get_parent node_ptr) h h'"

Output:
using get_child_nodes_reads[unfolded reads_def]
by(auto simp add: get_parent_def get_parent_locs_def intro!: reads_bind_pure reads_subset[OF check_in_heap_reads] reads_subset[OF get_child_nodes_reads] reads_subset[OF return_reads] reads_subset[OF object_ptr_kinds_M_reads] filter_M_reads filter_M_pure_I bind_pure_I)


Input: lemma restrict_bind_spmf: "bind_spmf p g \<upharpoonleft> A = p \<bind> (\<lambda>x. g x \<upharpoonleft> A)"

Output: by(auto simp add: bind_spmf_def restrict_bind_pmf cong del: option.case_cong_weak cong: option.case_cong intro!: bind_pmf_cong split: option.split)


Input:
lemma ennsqrt_strict_mono:
  "strict_mono ennsqrt"

Output:
unfolding ennsqrt_def
apply (rule strict_mono_compose[OF ennexp_strict_mono])
apply (rule strict_mono_compose[OF _ eln_strict_mono])
by (auto simp add: ereal_less_divide_pos ereal_mult_divide strict_mono_def)


Input:
lemma proj_tuple_replicate: "(\<And>i. i \<in> set bs \<Longrightarrow> \<not>i) \<Longrightarrow> length bs = length as \<Longrightarrow>
  proj_tuple bs as = replicate (length bs) None"

Output: by (induction bs as rule: proj_tuple.induct) fastforce+


Input: lemma advantage\<^sub>1_nonneg: "advantage\<^sub>1 \<A> \<eta> \<ge> 0"

Output: by(simp add: advantage\<^sub>1_def pmf_nonneg)


Input:
lemma less_eq_prod_simps [simp]:
  "(x1, x2) \<sqsubseteq> (y1, y2) \<longleftrightarrow> x1 \<sqsubset>\<^sub>a y1 \<or> x1 \<sqsubseteq>\<^sub>a y1 \<and> x2 \<sqsubseteq>\<^sub>b y2"

Output: by(simp add: less_eq_prod_def)


Input: lemma not_singleton_real_normed_is_perfect_space[simp]: \<open>class.perfect_space (open :: 'a::{not_singleton,real_normed_vector} set \<Rightarrow> bool)\<close>

Output:
apply standard
by (metis UNIV_not_singleton clopen closed_singleton empty_not_insert)


Input:
lemma ordIso_natLeq_on_imp_finite:
"|A| =o natLeq_on n \<Longrightarrow> finite A"

Output:
unfolding ordIso_def iso_def[abs_def]
by (auto simp: Field_natLeq_on bij_betw_finite)


Input: lemma valid_path_part_circlepath [simp]: "valid_path (part_circlepath z r s t)"

Output:
unfolding valid_path_def
by (auto simp: C1_differentiable_on_eq vector_derivative_works vector_derivative_part_circlepath has_vector_derivative_part_circlepath intro!: C1_differentiable_imp_piecewise continuous_intros)


Input:
lemma L_measurable[measurable]:
  "Measurable.pred S (L os)"

Output:
apply (induction os)
apply (simp; fail) subgoal premises that for o os
by(subst L_Cons) (intro Measurable.pred_intros_logic measurable_compose[OF measurable_shd] measurable_compose[OF measurable_stl that]; measurable) done


Input: lemma one_le_inverse_iff: "1 \<le> inverse x \<longleftrightarrow> 0 < x \<and> x \<le> 1"

Output: by (metis local.dual_order.strict_trans1 local.inverse_1 local.inverse_le_imp_le local.inverse_positive_iff_positive local.one_le_inverse local.zero_less_one)


Input:
lemma in_FvarsT_psubstTD:
assumes "y \<in> FvarsT (psubstT r txs)"
and "r \<in> atrm" and "snd ` (set txs) \<subseteq> var" and "fst ` (set txs) \<subseteq> atrm"
and "distinct (map snd txs)"
shows "y \<in> (FvarsT r - snd ` (set txs)) \<union>
           (\<Union> {if x \<in> FvarsT r then FvarsT t else {} | t x . (t,x) \<in> set txs})"

Output:
using assms FvarsT_psubstT
by auto


Input: lemma filterlim_inverse_at_right_top: "LIM x at_top. inverse x :> at_right (0::real)"

Output:
unfolding filterlim_at
by (auto simp: eventually_at_top_dense) (metis tendsto_inverse_0 filterlim_mono at_top_le_at_infinity order_refl)


Input: lemma Smith_normal_form_upt_k_0[simp]: "Smith_normal_form_upt_k A 0"

Output:
unfolding Smith_normal_form_upt_k_def unfolding isDiagonal_upt_k_def isDiagonal_def
by auto


Input: lemma iteration_refl: "1 \<le> x\<^sup>\<infinity>"

Output:
using local.iteration_unfoldl local.order_prop
by blast


Input:
lemma init_strong_tricolour_inv:
  "\<lbrakk> obj_mark ` ran (sys_heap \<lparr>GST = s, HST = []\<rparr>\<down>) \<subseteq> {gc_fM \<lparr>GST = s, HST = []\<rparr>\<down>}; sys_fM \<lparr>GST = s, HST = []\<rparr>\<down> = gc_fM \<lparr>GST = s, HST = []\<rparr>\<down> \<rbrakk>
     \<Longrightarrow> strong_tricolour_inv \<lparr>GST = s, HST = []\<rparr>\<down>"

Output:
unfolding strong_tricolour_inv_def ran_def white_def
by (auto split: obj_at_splits)


Input: lemma sup_pres_multr: "sup_pres (\<lambda>(z::'a::proto_near_quantale). z \<cdot> y)"

Output:
using Sup_pres_multr Sup_sup_pres
by fastforce


Input:
lemma nsqn\<^sub>r_zero [simp]:
  "\<And>dsn dsk flag hops nhip pre. nsqn\<^sub>r (0, dsk, flag, hops, nhip, pre) = 0"

Output:
unfolding nsqn\<^sub>r_def
by clarsimp


Input:
lemma zip_last :
  assumes "length r1 > 0"
  and     "length r1 = length r2"
shows "last (r1 || r2) = (last r1, last r2)"

Output: by (metis (no_types) assms(1) assms(2) less_nat_zero_code list.size(3) map_fst_zip zip_Nil zip_last)


Input:
lemma iso_comp:
  assumes "ChamberComplexIsomorphism Y Z g"
  shows   "ChamberComplexIsomorphism X Z (g\<circ>f)"

Output: by ( rule ChamberComplexIsomorphism.intro, rule comp, rule ChamberComplexIsomorphism.axioms(1), rule assms, unfold_locales, rule bij_betw_trans, rule bij_betw_vertices, rule ChamberComplexIsomorphism.bij_betw_vertices, rule assms ) (simp add: setsetmapim_comp surj_simplex_map assms ChamberComplexIsomorphism.surj_simplex_map )


Input:
lemma (in encoding) indRelTEQ_impl_TRel_is_weak_reduction_contrasimulation:
  fixes TRel :: "('procT \<times> 'procT) set"
  assumes conSim: "weak_reduction_contrasimulation (indRelTEQ TRel) (STCal Source Target)"
  shows "weak_reduction_contrasimulation (TRel\<^sup>*) Target"

Output:
using conSim indRelTEQ.target[where TRel="TRel"] indRelTEQ_to_TRel(4)[where TRel="TRel"] trans_closure_of_TRel_refl_cond rel_with_target_impl_reflC_transC_TRel_is_weak_reduction_contrasimulation[where Rel="indRelTEQ TRel" and TRel="TRel"]
by blast


Input:
lemma free_vars_integrate_vars[simp]:
    "free_vars (integrate_vars \<Gamma> vs e) = free_vars e - set vs"

Output: by (induction vs arbitrary: e) (auto simp: integrate_vars_def)


Input:
lemma ftype_preservation''':
  "\<lbrakk>find_path_f P ctx' cl = Some suffix; wf_program P; (ctx, cld) \<in> set suffix\<rbrakk>
      \<Longrightarrow> \<forall>prefix' suffix'.
            find_path_rec_f P ctx (cl_fqn (fqn_def (class_name_f cld))) prefix' = Some (prefix' @ suffix') \<and> ftype_in_path_f P suffix' f = Some ty \<longrightarrow>
                        ftype_in_path_f P suffix f = Some ty"

Output:
apply(cut_tac x = "(ctx, cld)" in ftype_preservation''''[of _ _ _ "[]", rule_format])
apply(simp add: find_path_f_def)+ done


Input: lemma T_tree23_of_list: "T_tree23_of_list as \<le> 3*(length as) + 4"

Output:
using T_join_all[of "leaves as"]
by(simp add: T_tree23_of_list_def T_leaves len_leaves)


Input:
lemma mut_del_barrier2_subseteq_mut_mo_valid_ref[locset_cache]: (* FIXME rename *)
  "mut_m.ins_barrier_locs \<subseteq> mut_m.mo_valid_ref_locs"

Output:
unfolding mut_m.ins_barrier_locs_def mut_m.mo_valid_ref_locs_def
by (auto intro: append_prefixD)


Input: lemma supp_asToHeap: "supp (asToHeap as) = supp as"

Output: by (induct as rule: asToHeap.induct) (simp_all add: exp_assn.supp supp_Nil supp_Cons supp_Pair sup_assoc)


Input: lemma sum_assoc_eqpoll: "elts ((a\<Uplus>b)\<Uplus>c) \<approx> elts (a\<Uplus>(b\<Uplus>c))"

Output:
unfolding eqpoll_def
by (metis sum_assoc_bij)


Input: lemma OclAnd10[simp]: "(False and False) = False"

Output: by(rule ext,simp add: OclAnd_def None_def invalid_def True_def False_def)


Input:
lemma (in insert_impl) insert_modifies:
  "\<forall>\<sigma>. \<Gamma>\<turnstile> {\<sigma>} \<acute>p :== PROC insert(\<acute>r,\<acute>p){t. t may_only_modify_globals \<sigma> in [next]}"

Output:
apply (hoare_rule HoarePartial.ProcRec1)
apply (vcg spec=modifies) done


Input: lemma "rec_BitList nil bit0 bit1 (Bit0 xs) = bit0 xs (rec_BitList nil bit0 bit1 xs)"

Output:
nitpick [expect = none]
apply simp done


Input:
lemma cat_smc_obj_intial[slicing_simps]:
  "obj_initial (cat_smc \<CC>) a \<longleftrightarrow> obj_initial \<CC> a"

Output: unfolding obj_initial_def obj_terminal_def unfolding smc_op_simps slicing_simps ..


Input:
lemma trace_rest_aux_append:
  "trace_rest_aux rest p (tr @ tr') = trace_rest_aux rest (trace_rest_aux rest p tr) tr'"

Output: by(induction p tr rule: trace_rest_aux.induct) auto


Input:
lemma new_element_get_child_nodes_is_l_new_element_get_child_nodes [instances]:
  "l_new_element_get_child_nodes type_wf known_ptr get_child_nodes get_child_nodes_locs"

Output:
using new_element_is_l_new_element get_child_nodes_is_l_get_child_nodes
apply(auto simp add: l_new_element_get_child_nodes_def l_new_element_get_child_nodes_axioms_def)[1]
using get_child_nodes_new_element new_element_no_child_nodes
by fast+


Input:
lemma i_cut_Un_disj: "
  \<lbrakk> cut_op = (\<down><) \<or> cut_op = (\<down>\<le>) \<or>
    cut_op = (\<down>>) \<or> cut_op = (\<down>\<ge>) \<rbrakk>
  \<Longrightarrow> cut_op (A \<union> B) t = cut_op A t \<union> cut_op B t"

Output:
apply (drule i_cut_set_restriction_disj[where f="\<lambda>I. cut_op I t"], simp)
by (rule set_restriction_Un)


Input:
lemma ta_union_wrap_rta:
  fixes TA TA'
  assumes TA: "ranked_tree_automaton TA A"
  assumes TA': "ranked_tree_automaton TA' A"
  shows "ranked_tree_automaton (ta_union_wrap TA TA') A"

Output:
proof - interpret ta: ranked_tree_automaton TA A
using TA . interpret ta': ranked_tree_automaton TA' A
using TA' . show ?thesis
by (unfold ta_union_wrap_def) (simp add: ta_union_rta)
qed


Input:
lemma wsX_if1:
  assumes "wsX G xcs"
  shows "(( atom ` fst ` set xcs) \<subseteq> atom_dom G) \<and> List.distinct (List.map fst xcs)"

Output:
using assms
by(induct rule: wsX.induct,force+ )


Input:
lemma supp_of_atom_list:
  fixes as::"atom list"
  shows "supp as = set as"

Output: by (induct as) (simp_all add: supp_Nil supp_Cons supp_atom)


Input:
lemma (in incidence_system) image_set_system_wellformed:
  "incidence_system (f ` \<V>) (blocks_image \<B> f)"

Output: by (unfold_locales, auto simp add: blocks_image_def) (meson image_eqI wf_invalid_point)


Input:
lemma wf_pddl_ground_act_is_sound_opr:
    assumes "wf_ground_action g_opr"
    shows "sound_opr g_opr (pddl_opr_to_act g_opr)"

Output:
using wf_eff_impt_wf_eff_inst wf_eff_pddl_ground_act_is_sound_opr assms
by (cases g_opr; auto)


Input: lemma nat_term_compare_inv_conv: "nat_term_compare_inv to = key_compare (key_order_of_nat_term_order_inv to)"

Output:
unfolding key_order_of_nat_term_order_inv_def
by (rule sym, rule Abs_key_order_inverse, simp add: comparator_nat_term_compare_inv)


Input: lemma evaldjf_ex: "Ifm bs (evaldjf f ps) = (\<exists> p \<in> set ps. Ifm bs (f p))"

Output: by (induct ps) (simp_all add: evaldjf_def djf_Or)


Input: lemma U0_in_NUM: "U\<^sub>0 \<in> NUM"

Output:
using prenum_in_R2 U0_altdef
by (intro NUM_I[of prenum]; force)


Input:
lemma pi_dom[icf_proper_iteratorI]:
    assumes P: "proper_it it it'"
    shows "proper_it (map_iterator_dom it)
      (map_iterator_dom it')"

Output:
unfolding proper_it_def
apply (rule proper_itE[OF P])
by (auto simp: map_iterator_dom_foldli_conv)


Input:
lemma dgrad_sig_set_closed_mult_scalar:
  "dickson_grading d \<Longrightarrow> p \<in> punit_dgrad_max_set d \<Longrightarrow> r \<in> dgrad_sig_set' j d \<Longrightarrow> p \<odot> r \<in> dgrad_sig_set' j d"

Output:
unfolding dgrad_sig_set'_def
by (auto intro: dgrad_p_set_closed_mult_scalar sig_inv_set_closed_mult_scalar)


Input:
lemma psubst_ball:
"\<phi> \<in> fmla \<Longrightarrow> y \<in> var \<Longrightarrow> snd ` set txs \<subseteq> var \<Longrightarrow> t \<in> atrm \<Longrightarrow>
 fst ` set txs \<subseteq> trm \<Longrightarrow> fst ` set txs \<subseteq> atrm \<Longrightarrow> y \<notin> snd ` set txs \<Longrightarrow> y \<notin> (\<Union>t \<in> fst ` set txs. FvarsT t) \<Longrightarrow>
 distinct (map snd txs) \<Longrightarrow>
 psubst (ball y t \<phi>) txs = ball y (psubstT t txs) (psubst \<phi> txs)"

Output:
unfolding ball_def
by simp


Input: lemma add_point_to_blocks_finite: "finite_incidence_system (add_point p) (add_point_to_blocks p bs)"

Output:
using add_point_blocks_wf add_point_finite finite_incidence_system.finite_sets incidence_system.finite_sysI
by blast


Input:
lemma interaction_bounded_by_PauseI [interaction_bound]:
  "(\<And>input. interaction_bounded_by consider (c input) (n input))
  \<Longrightarrow> interaction_bounded_by consider (Pause out c) (if consider out then 1 + (SUP input. n input) else (SUP input. n input))"

Output: by(auto simp add: iadd_is_0 enat_add_sub_same intro: interaction_bounded_by_mono SUP_upper)


Input: lemma Arg2pi_real: "z \<in> \<real> \<Longrightarrow> Arg2pi z = (if 0 \<le> Re z then 0 else pi)"

Output:
using Arg2pi_eq_0 Arg2pi_eq_0_pi
by auto


Input:
lemma stable_translation_length_nonneg [simp]:
  "stable_translation_length f \<ge> 0"

Output:
unfolding stable_translation_length_def
by (rule cInf_greatest, auto)


Input: lemma wprepare_erase_Bk_nonempty_list[simp]: "\<lbrakk>lm \<noteq> []; wprepare_erase m lm (b, Bk # list)\<rbrakk> \<Longrightarrow> list \<noteq> []"

Output: apply(simp only: wprepare_invs, auto) done


Input: lemma diffconst_sound_lemma:"sound (proof_result DiffConstProof)"

Output:
apply(rule
proof_sound) unfolding DiffConstProof_def
by (auto simp add: prover DiffConstProof_def DiffConstSubst_def Equals_def empty_def TUadmit_def)


Input:
lemma fail_reachable_ob :
  assumes "\<not> M1 \<preceq> M2"
  and     "well_formed M1"
  and     "well_formed M2"
  and     "observable M2"
  and "productF M2 M1 FAIL PM"
obtains p
where "path PM p (initial PM)" "target p (initial PM) = FAIL"

Output:
using assms fail_reachable
by (metis FSM.reachable_target_elim)


Input: lemma bin_last_bl_to_bin: "bin_last (bl_to_bin bs) \<longleftrightarrow> bs \<noteq> [] \<and> last bs"

Output: by(cases "bs = []")(auto simp add: bl_to_bin_def last_bin_last'[where w=0])


Input:
lemma assumes 1: "~x0"
  and 2: "~x30"
  and 3: "~x29"
  and 4: "~x59"
  and 5: "x1 | x31 | x0"
  and 6: "x2 | x32 | x1"
  and 7: "x3 | x33 | x2"
  and 8: "x4 | x34 | x3"
  and 9: "x35 | x4"
  and 10: "x5 | x36 | x30"
  and 11: "x6 | x37 | x5 | x31"
  and 12: "x7 | x38 | x6 | x32"
  and 13: "x8 | x39 | x7 | x33"
  and 14: "x9 | x40 | x8 | x34"
  and 15: "x41 | x9 | x35"
  and 16: "x10 | x42 | x36"
  and 17: "x11 | x43 | x10 | x37"
  and 18: "x12 | x44 | x11 | x38"
  and 19: "x13 | x45 | x12 | x39"
  and 20: "x14 | x46 | x13 | x40"
  and 21: "x47 | x14 | x41"
  and 22: "x15 | x48 | x42"
  and 23: "x16 | x49 | x15 | x43"
  and 24: "x17 | x50 | x16 | x44"
  and 25: "x18 | x51 | x17 | x45"
  and 26: "x19 | x52 | x18 | x46"
  and 27: "x53 | x19 | x47"
  and 28: "x20 | x54 | x48"
  and 29: "x21 | x55 | x20 | x49"
  and 30: "x22 | x56 | x21 | x50"
  and 31: "x23 | x57 | x22 | x51"
  and 32: "x24 | x58 | x23 | x52"
  and 33: "x59 | x24 | x53"
  and 34: "x25 | x54"
  and 35: "x26 | x25 | x55"
  and 36: "x27 | x26 | x56"
  and 37: "x28 | x27 | x57"
  and 38: "x29 | x28 | x58"
  and 39: "~x1 | ~x31"
  and 40: "~x1 | ~x0"
  and 41: "~x31 | ~x0"
  and 42: "~x2 | ~x32"
  and 43: "~x2 | ~x1"
  and 44: "~x32 | ~x1"
  and 45: "~x3 | ~x33"
  and 46: "~x3 | ~x2"
  and 47: "~x33 | ~x2"
  and 48: "~x4 | ~x34"
  and 49: "~x4 | ~x3"
  and 50: "~x34 | ~x3"
  and 51: "~x35 | ~x4"
  and 52: "~x5 | ~x36"
  and 53: "~x5 | ~x30"
  and 54: "~x36 | ~x30"
  and 55: "~x6 | ~x37"
  and 56: "~x6 | ~x5"
  and 57: "~x6 | ~x31"
  and 58: "~x37 | ~x5"
  and 59: "~x37 | ~x31"
  and 60: "~x5 | ~x31"
  and 61: "~x7 | ~x38"
  and 62: "~x7 | ~x6"
  and 63: "~x7 | ~x32"
  and 64: "~x38 | ~x6"
  and 65: "~x38 | ~x32"
  and 66: "~x6 | ~x32"
  and 67: "~x8 | ~x39"
  and 68: "~x8 | ~x7"
  and 69: "~x8 | ~x33"
  and 70: "~x39 | ~x7"
  and 71: "~x39 | ~x33"
  and 72: "~x7 | ~x33"
  and 73: "~x9 | ~x40"
  and 74: "~x9 | ~x8"
  and 75: "~x9 | ~x34"
  and 76: "~x40 | ~x8"
  and 77: "~x40 | ~x34"
  and 78: "~x8 | ~x34"
  and 79: "~x41 | ~x9"
  and 80: "~x41 | ~x35"
  and 81: "~x9 | ~x35"
  and 82: "~x10 | ~x42"
  and 83: "~x10 | ~x36"
  and 84: "~x42 | ~x36"
  and 85: "~x11 | ~x43"
  and 86: "~x11 | ~x10"
  and 87: "~x11 | ~x37"
  and 88: "~x43 | ~x10"
  and 89: "~x43 | ~x37"
  and 90: "~x10 | ~x37"
  and 91: "~x12 | ~x44"
  and 92: "~x12 | ~x11"
  and 93: "~x12 | ~x38"
  and 94: "~x44 | ~x11"
  and 95: "~x44 | ~x38"
  and 96: "~x11 | ~x38"
  and 97: "~x13 | ~x45"
  and 98: "~x13 | ~x12"
  and 99: "~x13 | ~x39"
  and 100: "~x45 | ~x12"
  and 101: "~x45 | ~x39"
  and 102: "~x12 | ~x39"
  and 103: "~x14 | ~x46"
  and 104: "~x14 | ~x13"
  and 105: "~x14 | ~x40"
  and 106: "~x46 | ~x13"
  and 107: "~x46 | ~x40"
  and 108: "~x13 | ~x40"
  and 109: "~x47 | ~x14"
  and 110: "~x47 | ~x41"
  and 111: "~x14 | ~x41"
  and 112: "~x15 | ~x48"
  and 113: "~x15 | ~x42"
  and 114: "~x48 | ~x42"
  and 115: "~x16 | ~x49"
  and 116: "~x16 | ~x15"
  and 117: "~x16 | ~x43"
  and 118: "~x49 | ~x15"
  and 119: "~x49 | ~x43"
  and 120: "~x15 | ~x43"
  and 121: "~x17 | ~x50"
  and 122: "~x17 | ~x16"
  and 123: "~x17 | ~x44"
  and 124: "~x50 | ~x16"
  and 125: "~x50 | ~x44"
  and 126: "~x16 | ~x44"
  and 127: "~x18 | ~x51"
  and 128: "~x18 | ~x17"
  and 129: "~x18 | ~x45"
  and 130: "~x51 | ~x17"
  and 131: "~x51 | ~x45"
  and 132: "~x17 | ~x45"
  and 133: "~x19 | ~x52"
  and 134: "~x19 | ~x18"
  and 135: "~x19 | ~x46"
  and 136: "~x52 | ~x18"
  and 137: "~x52 | ~x46"
  and 138: "~x18 | ~x46"
  and 139: "~x53 | ~x19"
  and 140: "~x53 | ~x47"
  and 141: "~x19 | ~x47"
  and 142: "~x20 | ~x54"
  and 143: "~x20 | ~x48"
  and 144: "~x54 | ~x48"
  and 145: "~x21 | ~x55"
  and 146: "~x21 | ~x20"
  and 147: "~x21 | ~x49"
  and 148: "~x55 | ~x20"
  and 149: "~x55 | ~x49"
  and 150: "~x20 | ~x49"
  and 151: "~x22 | ~x56"
  and 152: "~x22 | ~x21"
  and 153: "~x22 | ~x50"
  and 154: "~x56 | ~x21"
  and 155: "~x56 | ~x50"
  and 156: "~x21 | ~x50"
  and 157: "~x23 | ~x57"
  and 158: "~x23 | ~x22"
  and 159: "~x23 | ~x51"
  and 160: "~x57 | ~x22"
  and 161: "~x57 | ~x51"
  and 162: "~x22 | ~x51"
  and 163: "~x24 | ~x58"
  and 164: "~x24 | ~x23"
  and 165: "~x24 | ~x52"
  and 166: "~x58 | ~x23"
  and 167: "~x58 | ~x52"
  and 168: "~x23 | ~x52"
  and 169: "~x59 | ~x24"
  and 170: "~x59 | ~x53"
  and 171: "~x24 | ~x53"
  and 172: "~x25 | ~x54"
  and 173: "~x26 | ~x25"
  and 174: "~x26 | ~x55"
  and 175: "~x25 | ~x55"
  and 176: "~x27 | ~x26"
  and 177: "~x27 | ~x56"
  and 178: "~x26 | ~x56"
  and 179: "~x28 | ~x27"
  and 180: "~x28 | ~x57"
  and 181: "~x27 | ~x57"
  and 182: "~x29 | ~x28"
  and 183: "~x29 | ~x58"
  and 184: "~x28 | ~x58"
  shows "False"

Output:
using assms
by argo


Input:
lemma projs [simp]:
  "\<pi>\<^sub>2(dsn, dsk, flag, hops, nhip, pre) = dsn"
  "\<pi>\<^sub>3(dsn, dsk, flag, hops, nhip, pre) = dsk"
  "\<pi>\<^sub>4(dsn, dsk, flag, hops, nhip, pre) = flag"
  "\<pi>\<^sub>5(dsn, dsk, flag, hops, nhip, pre) = hops"
  "\<pi>\<^sub>6(dsn, dsk, flag, hops, nhip, pre) = nhip"
  "\<pi>\<^sub>7(dsn, dsk, flag, hops, nhip, pre) = pre"

Output: by (clarsimp simp: proj2_def proj3_def proj4_def proj5_def proj6_def proj7_def)+


Input:
lemma prod_rel_range[relator_props]: "\<lbrakk>Range Ra=UNIV; Range Rb=UNIV\<rbrakk>
  \<Longrightarrow> Range (\<langle>Ra,Rb\<rangle>prod_rel) = UNIV"

Output:
apply (auto simp: prod_rel_def)
by (metis Range_iff UNIV_I)+


Input:
lemma treewidth_upper_bound_ex:
  "\<lbrakk> TreeDecomposition G (T :: nat Graph) bag; TreeDecomposition.width T bag \<le> n \<rbrakk> \<Longrightarrow> treewidth \<le> n"

Output:
unfolding treewidth_def
by (metis (mono_tags, lifting) Min_le dual_order.trans mem_Collect_eq treewidth_cards_finite)


Input: lemma R20 [simp]: "pmf (sds R20) a = 0" "pmf (sds R20) c = 0" "pmf (sds R20) d = 1 - pmf (sds R20) b"

Output:
using R46_R20.strategyproofness(1) lottery_conditions[OF R20.wf]
by (auto simp del: pmf_nonneg)


Input: lemma continuous_on_norm_id [continuous_intros]: "continuous_on S norm"

Output: by (intro continuous_on_id continuous_on_norm)


Input:
lemma gval_fold_equiv_gval_foldr:
  "gval (fold gAnd G (Bc True)) s = gval (foldr gAnd G (Bc True)) s"

Output:
proof - have "gval (fold gAnd G (Bc True)) s = gval (fold gAnd (rev G) (Bc True)) s"
using gval_fold_equiv_fold_rev
by force then show ?thesis
by (simp add: foldr_conv_fold)
qed


Input: lemma assigned_nodes_pure [simp]: "pure (assigned_nodes slot) h"

Output: by(auto simp add: assigned_nodes_def intro!: bind_pure_I filter_M_pure_I)


Input:
lemma inj_image_filter_cartesian_product_alt:
    "inj_image_filter_cartesian_product f s1 s2 ==
     iterate_to_set s3.empty s3.ins_dj (set_iterator_image_filter f (
       set_iterator_product (s1.iteratei s1) (\<lambda>_. s2.iteratei s2)))"

Output:
unfolding inj_image_filter_cartesian_product_def iterate_to_set_alt_def set_iterator_image_filter_def set_iterator_product_def
by simp


Input: lemma liftE_handleE' [simp]: "((liftE a) <handle2> b) = liftE a"

Output: apply (clarsimp simp: liftE_def handleE'_def) done


Input:
lemma is_heap_merge:
  assumes "is_heap t1" "is_heap t2"
  shows "is_heap (merge t1 t2)"

Output:
using assms
by (auto simp add: merge_def)


Input: lemma of_rat_of_int_eq [simp]: "of_rat (of_int z) = of_int z"

Output: by (cases z rule: int_diff_cases) (simp add: of_rat_diff)


Input:
lemma list_remdups_conv_remdups [simp]:
  "equal_base.list_remdups (=) = List.remdups"

Output: unfolding equal_base.list_remdups_def List.remdups_def list_member_conv_member List.member_def ..


Input:
lemma Append_preserves_ardenable:
  "ardenable rhs \<Longrightarrow> ardenable (Append_rexp_rhs rhs r)"

Output:
apply (auto simp: ardenable_def Append_rexp_rhs_def)
by (case_tac x, auto simp: conc_def)


Input:
lemma eNorm_zero [simp]:
  "eNorm N 0 = 0"

Output: by (metis eNorm_cmult abs_zero ennreal_0 mult_zero_left real_vector.scale_zero_left)


Input: lemma arc_to_block_to_ends_swap: "{snd (arc_to_ends G e), fst (arc_to_ends G e)} = arc_to_block e"

Output:
using arc_to_block_to_ends
by (simp add: arc_to_block_to_ends insert_commute)


Input: lemma wsorted_map\<alpha>[simp]: "wsorted' s \<Longrightarrow> wsorted (map \<alpha> s)"

Output: by(auto simp: wsorted'_def sorted_wrt_map)


Input:
theorem Theorem_1_COP:
  "\<not>nonbossy ds Contracts.cop"

Output:
using ContractsWithBilateralSubstitutesAndIRC.Theorem_1 Theorem_1 mechanism_stable_def
by blast


Input:
lemma
  \<omega>_ne_0[simp]: "\<omega> \<noteq> 0" and
  \<omega>_ne_1[simp]: "\<omega> \<noteq> 1" and
  \<omega>_ne_of_nat[simp]: "\<omega> \<noteq> of_nat m" and
  \<omega>_ne_numeral[simp]: "\<omega> \<noteq> numeral n"

Output:
using zero_ne_\<omega> one_ne_\<omega> of_nat_ne_\<omega> numeral_ne_\<omega>
by metis+


Input: lemma create_alt_def[code]: "create = State (\<lambda>a. (next a, next a))"

Output:
unfolding create_def State_Monad.update_def State_Monad.get_def State_Monad.set_def State_Monad.bind_def
by simp


Input:
lemma S_transform_Conj [simp]:
  assumes "finite (supp xset)"
  shows "S_transform (Conj xset) = Conj (map_bset S_transform xset)"

Output:
using assms unfolding S_transform_def
by (simp, simp add: Conj_def bset.map_comp o_def)


Input:
lemma convert_closed:
  shows "\<And>i. i \<in> set_fml (fst (convert fml)) \<Longrightarrow> i < length (snd (convert fml))"

Output:
unfolding convert_def Let_def
apply (auto simp add: fml.set_map)
by (simp add: index_of_lookup(1) poly_list_set_fml)


Input:
lemma path_concat:
assumes "path f nl1" and "path f ((last nl1) # nl2)"
shows "path f (nl1 @ nl2)"

Output:
using assms
apply(induct rule: path.induct)
apply simp
by (metis append_Cons last.simps list.simps(3) path.Ind)


Input:
lemma while_zero_zero:
  "(x \<star> bot) \<star> bot = x \<star> bot"

Output: by (metis order.antisym mult_left_zero sup_bot_left while_left_unfold while_sub_associative while_mult_sub_while_while)


Input:
lemma enqueue_new_thread_eq_Nil [simp]:
  "enqueue_new_thread queue nta = [] \<longleftrightarrow> queue = [] \<and> (\<exists>t b. nta = ThreadExists t b)"

Output: by(cases nta) simp_all


Input:
lemma is_ok_sp_generalize2:
  assumes "is_ok (sp F xs (replicate n None))"
  shows "is_ok (sp F (map generalize_instr xs) (replicate n None))"

Output:
using assms is_ok_sp_generalize
by (metis Ex_list_of_length map_replicate_const)


Input: lemma fMin_less_Length[simp]: "x |\<in>| m1\<^bsup>\<AA>\<^esup>k \<Longrightarrow> fMin (m1\<^bsup>\<AA>\<^esup>k) < Length \<AA>"

Output: by transfer (force elim: order.strict_trans2[OF MSB_greater, rotated -1] intro: fMin_in split: order.splits)


Input: lemma results'_gpv_Done [simp]: "results'_gpv (Done x) = {x}"

Output: by(auto intro: results'_gpvI elim: results'_gpv_cases)


Input:
lemma JVM_states_unfold:
  "states P mxs mxl \<equiv> err(opt((Union {list n (types P) |n. n <= mxs}) \<times>
                                 list mxl (err(types P))))"

Output:
apply (unfold states_def sl_def Opt.esl_def Err.sl_def stk_esl_def loc_sl_def Product.esl_def Listn.sl_def upto_esl_def SemiType.esl_def Err.esl_def)
apply simp done


Input:
lemma (in network_with_ops) apply_operations_empty [simp]:
  shows "apply_operations [] = Some initial_state"

Output:
by(auto simp add:
apply_operations_def)


Input: lemma sets_D: "sets D = sets (stream_space (\<Pi>\<^sub>M s\<in>UNIV. count_space UNIV))"

Output: by (intro sets_stream_space_cong sets_PiM_cong) simp_all


Input: lemma t_stop_nonneg: "0 \<le> t_stop"

Output:
unfolding t_stop_def
using ego2.t_stop_nonneg pos_react
by auto


Input:
lemma is_rerr_asm [dest!]:
  assumes "\<xi>' \<in> is_rerr \<xi>"
    shows "(\<exists>dests' sip'.
               msg \<xi> = Rerr dests' sip' \<and>
               \<xi>' = \<xi>\<lparr> dests := dests', sip := sip' \<rparr>)"

Output:
using assms unfolding is_rerr_def
by (cases "msg \<xi>") simp_all


Input:
lemma finite_nonempty_carrier_has_minimum:
  assumes "carrier \<noteq> {}"
  shows "\<exists>e \<in> carrier. \<forall>m \<in> carrier. m \<succeq>[relation] e"

Output:
using finite_nempty_preorder_has_min[of carrier relation] assms \<open>finite carrier\<close> reflexivity total transitivity
by blast


Input:
lemma dy_fake_chan_extr_insert_parts:
  "M \<in> dy_fake_chan bad IK CH \<Longrightarrow>
   parts (extr bad IK (insert M CH)) \<subseteq> parts (extr bad IK CH) \<union> dy_fake_msg bad IK CH"

Output: by (drule dy_fake_chan_extr_insert [THEN parts_mono], auto simp add: dy_fake_msg_def)


Input:
lemma mpath_weight'_correct: "\<lbrakk>dinvarm (wl,res)\<rbrakk> \<Longrightarrow>
    mpath_weight' (res v) = path_weight' (\<alpha>r res v)
    "

Output:
unfolding dinvarm_def res_invarm_def \<alpha>r_def
by (auto split: option.split option.split_asm)


Input:
lemma reachable_If: "reachable (IF b THEN c1 ELSE c2) \<subseteq>
  {IF b THEN c1 ELSE c2} \<union> reachable c1 \<union> reachable c2"

Output: by(auto simp: reachable_def dest!: If_starD)


Input:
theorem "\<not> sudoku
    x11 x12  1  x14 x15  4  x17 x18 x19
    x21 x22 x23 x24  6  x26  3  x28  5
    x31 x32 x33  9  x35 x36 x37 x38 x39
     8  x42 x43 x44 x45 x46  7  x48  3
    x51 x52 x53 x54 x55 x56 x57  2   8
     5  x62 x63 x64  7  x66  6  x68 x69
     3  x72 x73 x74  8  x76 x77 x78  6
    x81 x82  9   2  x85 x86 x87 x88 x89
    x91  4  x93 x94 x95  1  x97 x98 x99"

Output: nitpick [expect=genuine] oops


Input:
lemma insert_before_wf_is_l_insert_before_wf [instances]:
  "l_insert_before_wf Shadow_DOM.heap_is_wellformed ShadowRootClass.type_wf
ShadowRootClass.known_ptr ShadowRootClass.known_ptrs
     Shadow_DOM.insert_before Shadow_DOM.get_child_nodes"

Output:
apply(auto simp add: l_insert_before_wf_def l_insert_before_wf_axioms_def instances)[1]
using insert_before_removes_child
apply fast done


Input:
lemma
  assumes "z \<noteq> 0"
  shows Arg_eq: "z = of_real(norm z) * exp(\<i> * Arg z)"

Output:
using assms exp_Ln exp_eq_polar
by (auto simp: Arg_def)


Input: lemma st_proj2_inv_ne_top: "st_proj2_inv xa \<noteq> bot_sphere"

Output: by transfer (auto simp: divide_simps add_nonneg_eq_0_iff)


Input: lemma NO_sub:"OadmitFO \<sigma> ODE A \<Longrightarrow> B \<subseteq> A \<Longrightarrow> OadmitFO \<sigma> ODE B"

Output: by(induction ODE, auto simp add: OUadmitFO_def)


Input:
lemma composite_in_hom [intro]:
    shows "\<guillemotleft>\<mu> \<star> \<nu> \<star> \<pi> : dom \<mu> \<star> dom \<nu> \<star> dom \<pi> \<Rightarrow> cod \<mu> \<star> cod \<nu> \<star> cod \<pi>\<guillemotright>"
    and "\<guillemotleft>(\<mu> \<star> \<nu>) \<star> \<pi> : (dom \<mu> \<star> dom \<nu>) \<star> dom \<pi> \<Rightarrow> (cod \<mu> \<star> cod \<nu>) \<star> cod \<pi>\<guillemotright>"

Output:
using \<mu>\<nu>.composable \<nu>\<pi>.composable
by auto


Input: theorem negative_resolvent_is_finite : "derived_clauses_are_finite ordered_negative_resolvent"

Output:
using less_restrictive_and_finite negative_resolvent_is_resolvent resolvent_is_finite
by auto


Input: lemma "(unfold_ruleset_CHAIN_safe chain a rs = Some rs') \<Longrightarrow> simple_ruleset rs'"

Output: by(simp add: Let_def unfold_ruleset_CHAIN_safe_def unfold_optimize_ruleset_CHAIN_def split: if_split_asm)


Input: lemma "continuous_on UNIV inv_stereographic"

Output:
unfolding continuous_on_iff unfolding dist_complex_homo_def dist_riemann_sphere_def
by (subst dist_stereographic, auto)


Input: lemma balance_left_inv1l: "\<lbrakk> inv1l lt; inv1 rt \<rbrakk> \<Longrightarrow> inv1l (balance_left lt k x rt)"

Output: by (induct lt k x rt rule: balance_left.induct) (auto simp: balance_inv1)


Input: lemma abs_summable_on_altdef: "f abs_summable_on A \<longleftrightarrow> set_integrable (count_space UNIV) A f"

Output:
unfolding abs_summable_on_def set_integrable_def
by (metis (no_types) inf_top.right_neutral integrable_restrict_space restrict_count_space sets_UNIV)


Input:
lemma
  assumes "solution z"
  shows   pell_mul_cnj_right: "pell_mul z (pell_cnj z) = (1, 0)"
    and   pell_mul_cnj_left: "pell_mul (pell_cnj z) z = (1, 0)"

Output:
using assms
by (auto simp: pell_mul_def pell_cnj_def solution_def power2_eq_square)


Input:
lemma vec_of_basis_enum_zero:
  defines "nA \<equiv> length (canonical_basis :: 'a::basis_enum list)"
  shows "vec_of_basis_enum (0::'a) = 0\<^sub>v nA"

Output: by (metis assms carrier_vecI dim_vec_of_basis_enum' minus_cancel_vec right_minus_eq vec_of_basis_enum_minus)


Input:
lemma ctxt_sub_cong:
  assumes "closed e1"
  assumes "closed e2"
  assumes "evalDdb e1\<cdot>env_empty_db = evalDdb e2\<cdot>env_empty_db"
  shows "evalDdb (C<e1>)\<cdot>env_empty_db = evalDdb (C<e2>)\<cdot>env_empty_db"

Output:
unfolding ctxt_sub_def
using assms
by (auto intro: closing_subst_evalDdb_cong)


Input:
lemma cblinfun_blinfun_transfer_minus[cblinfun_blinfun_transfer]:
  includes lifting_syntax
  shows "(blinfun_cblinfun_eq ===> blinfun_cblinfun_eq ===> blinfun_cblinfun_eq) (-) (-)"

Output:
unfolding rel_fun_def
apply transfer
by auto


Input:
lemma eSubstInp_simp3[simp]:
assumes *: "\<not> igWls MOD (asSort ys) Y" and **: "\<not> einp = (\<lambda> i. None)"
shows "\<not> liftAll (\<lambda>eX. eX \<noteq> ERR) (eSubstInp MOD ys (OK Y) y einp)"

Output:
using assms
by (auto simp: igSubstInp_def liftAll_lift_comp lift_def liftAll_def split: option.splits)


Input:
lemma P1_real_ideal_DDH_advantage_True:
  assumes "\<sigma> = True"
  shows "mal_def.adv_P1 M \<sigma> z (P1_S1, P1_S2) \<A> D = ddh.DDH_advantage (P1_DDH_mal_adv_\<sigma>_True M z \<A> D)"

Output: by(simp add: P1_adv_real_ideal_model_def ddh.DDH_advantage_def P1_real_ddh1_\<sigma>_True P1_ideal_ddh0_\<sigma>_True assms P1_advantages_eq)


Input:
lemma Quotient_resumption [quot_map]:
  "\<lbrakk> Quotient R1 Abs1 Rep1 T1; Quotient R2 Abs2 Rep2 T2 \<rbrakk>
  \<Longrightarrow> Quotient (rel_resumption R1 R2) (map_resumption Abs1 Abs2) (map_resumption Rep1 Rep2) (rel_resumption T1 T2)"

Output: by(simp add: Quotient_alt_def5 resumption.rel_Grp[of UNIV _ UNIV _, symmetric, simplified] resumption.rel_compp resumption.rel_conversep[symmetric] resumption.rel_mono)


Input: lemma mat0[simp,intro]: "mat nr nc (mat0I ze nr nc)"

Output:
unfolding mat_def mat0I_def
using replicate_prop[of "vec nr" "vec0I ze nr" "nc"]
by simp


Input:
lemma comp_converter_map1_out:
  "comp_converter (map_converter f g id id conv) conv' = map_converter f g id id (comp_converter conv conv')"

Output: by(simp add: comp_converter_map_converter1)


Input: lemma mset_radix_sort: "mset (radix_sort i xss) = mset xss"

Output: by(induction i arbitrary: xss) (auto simp: mset)


Input: lemma primorial_pos [simp, intro]: "primorial x > 0"

Output:
unfolding primorial_def
by (intro prod_pos) (auto dest: prime_gt_0_nat)


Input:
lemma sup_case_exp_case_exp_same:
  "sup_class.sup
    (case_exp cNew cNewArray cCast cInstanceOf cVal cBinOp cVar cLAss cAAcc cAAss cALen cFAcc cFAss cCAS cCall cBlock cSync cInSync cSeq cCond cWhile cThrow cTry e)
    (case_exp cNew' cNewArray' cCast' cInstanceOf' cVal' cBinOp' cVar' cLAss' cAAcc' cAAss' cALen' cFAcc' cFAss' cCAS' cCall' cBlock' cSync' cInSync' cSeq' cCond' cWhile' cThrow' cTry' e) =
  (case e of
    new C \<Rightarrow> sup_class.sup (cNew C) (cNew' C)
  | newArray T e \<Rightarrow> sup_class.sup (cNewArray T e) (cNewArray' T e)
  | Cast T e \<Rightarrow> sup_class.sup (cCast T e) (cCast' T e)
  | InstanceOf e T \<Rightarrow> sup_class.sup (cInstanceOf e T) (cInstanceOf' e T)
  | Val v \<Rightarrow> sup_class.sup (cVal v) (cVal' v)
  | BinOp e bop e' \<Rightarrow> sup_class.sup (cBinOp e bop e') (cBinOp' e bop e')
  | Var V \<Rightarrow> sup_class.sup (cVar V) (cVar' V)
  | LAss V e \<Rightarrow> sup_class.sup (cLAss V e) (cLAss' V e)
  | AAcc a e \<Rightarrow> sup_class.sup (cAAcc a e) (cAAcc' a e)
  | AAss a i e \<Rightarrow> sup_class.sup (cAAss a i e) (cAAss' a i e)
  | ALen a \<Rightarrow> sup_class.sup (cALen a) (cALen' a)
  | FAcc e F D \<Rightarrow> sup_class.sup (cFAcc e F D) (cFAcc' e F D)
  | FAss e F D e' \<Rightarrow> sup_class.sup (cFAss e F D e') (cFAss' e F D e')
  | CompareAndSwap e D F e' e'' \<Rightarrow> sup_class.sup (cCAS e D F e' e'') (cCAS' e D F e' e'')
  | Call e M es \<Rightarrow> sup_class.sup (cCall e M es) (cCall' e M es)
  | Block V T vo e \<Rightarrow> sup_class.sup (cBlock V T vo e) (cBlock' V T vo e)
  | Synchronized v e e' \<Rightarrow> sup_class.sup (cSync v e e') (cSync' v e e')
  | InSynchronized v a e \<Rightarrow> sup_class.sup (cInSync v a e) (cInSync' v a e)
  | Seq e e' \<Rightarrow> sup_class.sup (cSeq e e') (cSeq' e e')
  | Cond b e e' \<Rightarrow> sup_class.sup (cCond b e e') (cCond' b e e')
  | While b e \<Rightarrow> sup_class.sup (cWhile b e) (cWhile' b e)
  | throw e \<Rightarrow> sup_class.sup (cThrow e) (cThrow' e)
  | TryCatch e C V e' \<Rightarrow> sup_class.sup (cTry e C V e') (cTry' e C V e'))"

Output:
apply(cases e)
apply(simp_all) done


Input: lemma fg_symmetric: "OpposedThinChamberComplexFoldings X g f D0"

Output:
using chambers(2-4) chamber_D0 adjacent_sym
by unfold_locales auto


Input:
lemma (in encoding) indRelT_to_TRel:
  fixes TRel  :: "('procT \<times> 'procT) set"
    and TP TQ :: "'procT"
  assumes rel: "TargetTerm TP \<R>\<lbrakk>\<cdot>\<rbrakk>T<TRel> TargetTerm TQ"
  shows "(TP, TQ) \<in> TRel"

Output:
using rel
by (simp add: indRelT.simps)


Input: lemma rotate_toppos_inv:"rotate_toppos w1 w2 \<Longrightarrow> (kauff_mat w1) = (kauff_mat w2)"

Output:
unfolding rotate_toppos_def
using rotate_toppos_kauff_mat
by auto


Input:
lemma embed_transaction_simps [simp]:
  "embed_transaction (Transaction cm pm views) =
   Transaction\<^sub>m (Unblinded ((Unblinded cm, Unblinded pm), map embed_view views))"
  for views

Output:
unfolding Transaction_Transaction'
by transfer simp


Input:
lemma length_concat_merge_pairs [simp]:
  "length (concat (merge_pairs xss)) = length (concat xss)"

Output: by (induct xss rule: merge_pairs.induct) simp_all


Input:
lemma parallel_converter2_comp2_out:
  "parallel_converter2 conv'' (comp_converter conv conv') = comp_converter (parallel_converter2 id_converter conv) (parallel_converter2 conv'' conv')"

Output: by(simp add: comp_converter_parallel2 comp_converter_id_left)


Input:
lemma nonregular_event:
  "~ regular_event ev = (isSnapshot ev \<or> isRecvMarker ev)"

Output: by (meson event.distinct_disc event.exhaust_disc regular_event)


Input:
lemma transfer_FOREACHci_nres[refine_transfer]:
  assumes A: "set_iterator iterate s"
  assumes R: "\<And>x \<sigma>. nres_of (fi x \<sigma>) \<le> f x \<sigma>"
  shows "nres_of (dres_it iterate c fi \<sigma>) \<le> FOREACHci I s c f \<sigma>"

Output:
using assms unfolding FOREACHci_def set_iterator_def
by (rule transfer_FOREACHoci_nres)


Input:
lemma Ch_CH_irc_idem:
  shows "Ch h (CH A) = Ch h A"

Output:
using %invisible CH_domain CH_irc_idem Ch_domain
by blast


Input:
lemma card_com_lookup [unfolded length_map, simp]:
  "card (dom (lookup (t :: ('a, 'b) mapping_rbt))) = length (List.map fst (entries t))"

Output: by transfer(auto simp add: linorder.rbt_lookup_keys[OF mapping_linorder] linorder.distinct_entries[OF mapping_linorder] RBT_Impl.keys_def ord.is_rbt_rbt_sorted ID_ccompare_neq_None List.card_set simp del: set_map length_map)


Input: lemma mem_correct_tracing: "mem_correct lookup_trace update_trace (P o snd)"

Output: by standard (auto intro!: lift_pI elim: lift_p_P[OF lookup_inv] simp: lookup_trace_def update_trace_def state_mem_defs.map_of_def map_of_simp split: prod.splits option.splits; metis snd_conv lookup_correct update_correct lift_p_P update_inv lookup_inv lift_p_P )+


Input:
lemma  Z_I_unitary:
  shows "unitary Z_I"

Output:
unfolding Z_I_def
using tensor_mat_unitary[of Z "1\<^sub>m 2"] Z_carrier unitary_Z
using unitary_one
by auto


Input:
lemma negative_resolvent_is_model_res:
  "less_restrictive ordered_negative_resolvent (ordered_model_resolvent UNIV)"

Output:
unfolding ordered_negative_resolvent_def ordered_model_resolvent_def less_restrictive_def
using positive_part_lemma
by auto


Input:
lemma Z_I_hermitian:
  shows "hermitian Z_I"

Output:
unfolding Z_I_def
using tensor_mat_hermitian[of Z 2 "1\<^sub>m 2" 2]
by (simp add: Z_carrier Z_hermitian hermitian_one)


Input: lemma carrier_Fexp': "carrier (Texp e\<cdot>a) \<subseteq> fv e"

Output:
unfolding Texp_simp carrier_ccTTree
by (rule Aexp_edom)


Input: lemma lim_1_over_ln: "((\<lambda>n. 1 / ln(real_of_nat n)) \<longlongrightarrow> 0) sequentially"

Output:
using lim_1_over_Ln [THEN filterlim_sequentially_Suc [THEN iffD2]]
apply (subst filterlim_sequentially_Suc [symmetric])
by (simp add: lim_sequentially dist_norm Ln_Reals_eq norm_powr_real_powr norm_divide)


Input:
lemma (in encoding) full_abstraction_impl_SRel_iff_TRel_is_sym:
  fixes SRel :: "('procS \<times> 'procS) set"
    and TRel :: "('procT \<times> 'procT) set"
  assumes fullAbs: "fully_abstract SRel TRel"
  shows "sym SRel \<longleftrightarrow> sym {(T1, T2). \<exists>S1 S2. T1 = \<lbrakk>S1\<rbrakk> \<and> T2 = \<lbrakk>S2\<rbrakk> \<and> (T1, T2) \<in> TRel}"

Output:
unfolding sym_def
by (simp add: fullAbs, blast)


Input:
lemma terminated_GST_stable:
  assumes "system_step q sh' sh"
  assumes "terminated p sh"
  shows "GST sh p = GST sh' p"

Output:
using assms
by (auto dest!: terminated_no_commands simp: small_step_stuck elim!: system_step.cases)


Input: lemma canAccessThis_simp2: "canAccessThis \<noteq> vertex_1 \<Longrightarrow> succ_tran \<lparr>nodes = {vertex_1, canAccessThis}, edges = {(vertex_1, canAccessThis)}\<rparr> canAccessThis = {}"

Output:
apply (simp add: succ_tran_def)
by (metis Domain.DomainI Domain_empty Domain_insert singleton_iff trancl_domain)


Input:
lemma check_certD:
  "check_cert G mxs mxr n cert \<Longrightarrow> cert_ok cert n Err (OK None) (states G mxs mxr)"

Output:
apply (unfold cert_ok_def check_cert_def check_types_def)
apply (auto simp add: list_all_iff) done


Input:
lemma dflt_plain_comb[sepref_monadify_comb]:
  "EVAL$(If$b$t$e) \<equiv> Refine_Basic.bind$(EVAL$b)$(\<lambda>\<^sub>2b. If$b$(EVAL$t)$(EVAL$e))"
  "EVAL$(case_list$fn$(\<lambda>\<^sub>2x xs. fc x xs)$l) \<equiv>
    Refine_Basic.bind$(EVAL$l)$(\<lambda>\<^sub>2l. case_list$(EVAL$fn)$(\<lambda>\<^sub>2x xs. EVAL$(fc x xs))$l)"
  "EVAL$(case_prod$(\<lambda>\<^sub>2a b. fp a b)$p) \<equiv>
    Refine_Basic.bind$(EVAL$p)$(\<lambda>\<^sub>2p. case_prod$(\<lambda>\<^sub>2a b. EVAL$(fp a b))$p)"
  "EVAL$(case_option$fn$(\<lambda>\<^sub>2x. fs x)$ov) \<equiv>
    Refine_Basic.bind$(EVAL$ov)$(\<lambda>\<^sub>2ov. case_option$(EVAL$fn)$(\<lambda>\<^sub>2x. EVAL$(fs x))$ov)"
  "EVAL $ (Let $ v $ (\<lambda>\<^sub>2x. f x)) \<equiv> (\<bind>) $ (EVAL $ v) $ (\<lambda>\<^sub>2x. EVAL $ (f x))"

Output: apply (rule eq_reflection, simp split: list.split prod.split option.split)+ done


Input:
lemma P1_real_ideal_DDH_advantage_False_bound:
  assumes "\<sigma> = False"
  shows "mal_def.adv_P1 M \<sigma> z (P1_S1, P1_S2) \<A> D
          \<le> ddh.advantage (P1_DDH_mal_adv_\<sigma>_False M z \<A> D)
            + ddh.advantage (ddh.DDH_\<A>' (P1_DDH_mal_adv_\<sigma>_False M z \<A> D))"

Output:
using P1_real_ideal_DDH_advantage_False ddh.DDH_advantage_bound assms
by metis


Input:
lemma GSMP_disjoint_empty[simp]:
  "GSMP_disjoint {} A Sec" "GSMP_disjoint A {} Sec"

Output:
unfolding GSMP_disjoint_def GSMP_def
by fastforce+


Input:
lemma finite_succeed_t:
  "finite (succeed i) = finite (succeed_t i)"

Output:
using finite_succeed_t' finite_succeed_t''
by blast


Input: lemma rot_circle_left_bot_edges_neq [simp]: "rot_circle_left_edge \<noteq> rot_circle_top_edge"

Output:
apply (simp add: rot_circle_top_edge_def rot_circle_left_edge_def)
by (metis (no_types, hide_lams) cancel_comm_monoid_add_class.diff_cancel d_gt_0 mult.commute mult_zero_right nonzero_mult_div_cancel_left order_less_irrefl prod.sel(2) times_divide_eq_right x_coord_def zero_neq_numeral)


Input:
lemma wf_sig_imp_exe_wf_sig': "exe_sig_conds \<Sigma> \<Longrightarrow>
    wf_sig (translate_signature \<Sigma>) \<Longrightarrow>
    exe_wf_sig \<Sigma>"

Output: by (metis exe_sig_conds_def exesignature.exhaust_sel wf_sig_iff_exe_wf_sig translate_signature.simps)


Input:
theorem ParT_ZObis[simp]:
assumes "properL cl" and "properL dl" and "SbisL cl dl"
shows "ParT cl \<approx>01 ParT dl"

Output:
using assms thetaZOParT_ZObis unfolding thetaZOParT_def
by blast