Input:
lemma integrableI_simple_bochner_integrable:
  fixes f :: "'a \<Rightarrow> 'b::{banach, second_countable_topology}"
  shows "simple_bochner_integrable M f \<Longrightarrow> integrable M f"

Output: by (intro integrableI_sequence[where s="\<lambda>_. f"] borel_measurable_simple_function) (auto simp: zero_ennreal_def[symmetric] simple_bochner_integrable.simps)


Input:
lemma triangle_left:
    shows "(\<epsilon> \<star> f) \<cdot> \<a>\<^sup>-\<^sup>1[f, g, f] \<cdot> (f \<star> \<eta>) = f"

Output:
using triangle_left strict_lunit strict_runit
by simp


Input:
lemma pmu_unfold:
  "has_least_prefixpoint f \<Longrightarrow> f (p\<mu> f) \<le> p\<mu> f"

Output:
using is_least_prefixpoint_def least_prefixpoint
by blast


Input:
lemma lm157:
  assumes "X \<subseteq> Domain f" "runiq f"
  shows "f``X = (eval_rel f)`X"

Output:
using assms lm156
by (metis restrictedRange lm153 lm155 toFunction_def)


Input:
lemma rep_dom:
    assumes "arr f"
    shows "rep (dom f) = \<^bold>\<parallel>DOM f\<^bold>\<parallel>"

Output:
using assms dom_simp rep_mkarr Arr_rep Arr_implies_Ide_Dom
by simp


Input:
lemma cmult_in_bigo_iff    [simp]:  "(\<lambda>x. c * f x) \<in> O[F](g) \<longleftrightarrow> c = 0 \<or> f \<in> O[F](g)"
  and cmult_in_bigo_iff'   [simp]:  "(\<lambda>x. f x * c) \<in> O[F](g) \<longleftrightarrow> c = 0 \<or> f \<in> O[F](g)"
  and cmult_in_smallo_iff  [simp]:  "(\<lambda>x. c * f x) \<in> o[F](g) \<longleftrightarrow> c = 0 \<or> f \<in> o[F](g)"
  and cmult_in_smallo_iff' [simp]: "(\<lambda>x. f x * c) \<in> o[F](g) \<longleftrightarrow> c = 0 \<or> f \<in> o[F](g)"

Output: by (cases "c = 0", simp, simp)+


Input:
lemma to_poly_inverse:
  assumes "f \<in> carrier P"
  assumes "degree f = 0"
  shows "f = to_poly (f 0)"

Output:
using P_def assms(1) assms(2)
by (metis ltrm_deg_0 to_polynomial_def)


Input:
lemma diagonalize_strict_arr:
    assumes "\<F>\<^sub>SC.arr f"
    shows "D f = f"

Output:
using assms arr_char D_def strict_arr_char Arr_rep Arr_implies_Ide_Dom Ide_implies_Arr mkarr_Diagonalize_rep [of f]
by auto


Input: lemma has_sgnx_inverse: "(f has_sgnx c) F \<longleftrightarrow> ((inverse o f) has_sgnx (inverse c)) F"

Output:
unfolding has_sgnx_def comp_def
apply (rule eventually_subst)
apply (rule always_eventually)
by (metis inverse_inverse_eq sgn_inverse)


Input:
lemma DERIV_pos_inc_right:
  fixes f :: "real \<Rightarrow> real"
  assumes der: "DERIV f x :> l"
    and l: "0 < l"
  shows "\<exists>d > 0. \<forall>h > 0. h < d \<longrightarrow> f x < f (x + h)"

Output:
using has_real_derivative_pos_inc_right[OF assms]
by auto


Input:
lemma summableI[intro, simp]: "summable f"
  for f :: "nat \<Rightarrow> 'a::{canonically_ordered_monoid_add,linorder_topology,complete_linorder}"

Output: by (intro summableI_nonneg_bounded[where x=top] zero_le top_greatest)


Input:
lemma continuous_on_infnorm[continuous_intros]:
  "continuous_on s f \<Longrightarrow> continuous_on s (\<lambda>x. infnorm (f x))"

Output:
unfolding continuous_on
by (fast intro: tendsto_infnorm)


Input:
lemma continuous_on_iff_ereal:
  fixes f :: "'a::t2_space => real"
  assumes "open A"
  shows "continuous_on A f \<longleftrightarrow> continuous_on A (ereal \<circ> f)"

Output: unfolding continuous_on_def comp_def lim_ereal ..


Input:
lemma finiteDomainImpliesFinite:
  assumes "runiq f"
  shows "finite (Domain f) = finite f"

Output:
using assms Domain_empty_iff card_eq_0_iff finite.emptyI lm076
by metis


Input:
lemma abs_term_apply_const[simp]:
  "is_Val f \<Longrightarrow> Fun f [] \<cdot>\<^sub>\<alpha> a = Fun (Abs (a (the_Val f))) []"
  "\<not>is_Val f \<Longrightarrow> Fun f [] \<cdot>\<^sub>\<alpha> a = Fun f []"

Output: by (cases f; auto)+


Input:
lemma tendsto_of_int_ceiling:
  fixes f::"'a \<Rightarrow> 'b::{order_topology,floor_ceiling}"
  assumes "(f \<longlongrightarrow> l) F"
    and "l \<notin> \<int>"
  shows "((\<lambda>x. of_int (ceiling (f x)):: 'c::{ring_1,topological_space}) \<longlongrightarrow> of_int (ceiling l)) F"

Output:
using eventually_ceiling_eq[OF assms]
by (simp add: eventually_mono topological_tendstoI)


Input:
lemma integral_lebesgue:
  fixes f :: "'a::euclidean_space \<Rightarrow> 'b::euclidean_space"
  shows "integrable lebesgue f \<Longrightarrow> integral UNIV f = (\<integral>x. f x \<partial>lebesgue)"

Output:
using has_integral_integral_lebesgue
by auto


Input:
lemma has_vector_derivative_transform:
  assumes "x \<in> S" "\<And>x. x \<in> S \<Longrightarrow> g x = f x"
  assumes f': "(f has_vector_derivative f') (at x within S)"
  shows "(g has_vector_derivative f') (at x within S)"

Output:
using assms unfolding has_vector_derivative_def
by (rule has_derivative_transform)


Input:
lemma filterlim_at_top_linear_iff:
  fixes f::"'a::linordered_field \<Rightarrow> 'b"
  assumes "c\<noteq>0"
  shows "(LIM x at_top. f (x * c + b) :> F2) \<longleftrightarrow> (if c>0 then (LIM x at_top. f x :> F2)
            else (LIM x at_bot. f x :> F2))"

Output:
unfolding filterlim_def
apply (subst filtermap_filtermap[of f "\<lambda>x. x * c + b",symmetric])
using assms
by (auto simp add:filtermap_at_top_linear_eq)


Input:
lemma countable_bipartite_web_minus_web:
  assumes f: "current \<Gamma> f"
  shows "countable_bipartite_web (\<Gamma> \<ominus> f)"

Output:
using bipartite_V A_vertex bipartite_E disjoint currentD_finite_OUT[OF f] currentD_weight_OUT[OF f] currentD_weight_IN[OF f] currentD_outside_OUT[OF f] currentD_outside_IN[OF f]
by unfold_locales (auto simp add: weight_outside)


Input:
lemma res_fold_A_A_chamber_image:
  "ChamberComplex.chamber A F \<Longrightarrow> res_fold_A ` F = fold_A ` F"

Output:
using apartments(1) apartment_chamberD_simplex restrict1_image
by fastforce


Input:
lemma maxsimp_map:
  "maxsimp x \<Longrightarrow> SimplicialComplex.maxsimp (f\<turnstile>X) (f`x)"

Output:
using maxsimpD_simplex maxsimp_im_max morph SimplicialComplex.maxsimpI[of "f\<turnstile>X" "f`x"]
by fastforce


Input:
lemma field_differentiable_imp_continuous_at:
    "f field_differentiable (at x within S) \<Longrightarrow> continuous (at x within S) f"

Output: by (metis DERIV_continuous field_differentiable_def)


Input:
lemma n_mult_degree_bound:
  assumes "f \<in> carrier P"
  shows "degree (n_mult f) \<le> degree f"

Output:
apply(rule deg_leqI)
apply (simp add: assms n_mult_closed)
by (simp add: assms deg_leE n_mult_def)


Input:
lemma incls_coherent:
    assumes "par f f'" and "incl f" and "incl f'"
    shows "f = f'"

Output:
using assms incl_def fun_complete
by auto


Input:
lemma openin_Inter [intro]:
  assumes "finite \<F>" "\<F> \<noteq> {}" "\<And>X. X \<in> \<F> \<Longrightarrow> openin T X" shows "openin T (\<Inter>\<F>)"

Output: by (metis (full_types) assms openin_INT2 image_ident)


Input:
lemma tendsto_divide_zero:
  fixes c :: "'a::real_normed_field"
  shows "(f \<longlongrightarrow> 0) F \<Longrightarrow> ((\<lambda>x. f x / c) \<longlongrightarrow> 0) F"

Output: by (cases "c=0") (simp_all add: divide_inverse tendsto_mult_left_zero)


Input:
lemma absolutely_integrable_periodic_offset:
  fixes f :: "real \<Rightarrow> real"
  assumes f: "f absolutely_integrable_on {a..b}" and periodic: "\<And>x. f(x + (b-a)) = f x"
  shows "(\<lambda>x. f(x + c)) absolutely_integrable_on {a..b}" "(\<lambda>x. f(c + x)) absolutely_integrable_on {a..b}"

Output:
using assms integrable_periodic_offset [of a b "f"]
by (auto simp: integrable_restrict_space set_integrable_def add.commute [of c])


Input:
lemma hensel_factor_id:
"(divide (f\<bullet>a) (f'\<bullet>a)) \<otimes> ((f'\<bullet>a)) = (f\<bullet>a)"

Output:
using hensel_hypothesis hensel_axioms divide_formula f'a_closed fa_closed hensel_hypothesis_weakened mult_comm
by auto


Input:
lemma functor_is_transformation [simp]:
  assumes "functor A B F"
  shows "natural_transformation A B F F F"

Output:
proof - interpret "functor" A B F
using assms
by auto show "natural_transformation A B F F F"
using is_extensional B.comp_arr_dom B.comp_cod_arr
by (unfold_locales, simp_all)
qed


Input:
lemma fls_inverse_base2:
  fixes f :: "'a::{comm_monoid_add,mult_zero,uminus,inverse} fls"
  shows "inverse f $$ (-fls_subdegree f) = inverse (f $$ fls_subdegree f)"

Output: by (cases "f=0") (simp_all add: fls_inverse_zero_conv_fls_const fls_inverse_def')


Input:
lemma eventually_nonzero_inverse [eventually_nonzero_simps]:
  "eventually_nonzero F (\<lambda>x. inverse (f x)) \<longleftrightarrow> eventually_nonzero F f"

Output:
unfolding eventually_nonzero_def
by simp


Input:
lemma minus_web_sel [simp]:
  "edge (\<Gamma> \<ominus> f) = edge \<Gamma>"
  "weight (\<Gamma> \<ominus> f) x = (if x \<in> A \<Gamma> then weight \<Gamma> x - d_OUT f x else weight \<Gamma> x + d_OUT f x - d_IN f x)"
  "A (\<Gamma> \<ominus> f) = A \<Gamma>"
  "B (\<Gamma> \<ominus> f) = B \<Gamma>"
  "\<^bold>V\<^bsub>\<Gamma> \<ominus> f\<^esub> = \<^bold>V\<^bsub>\<Gamma>\<^esub>"
  "\<^bold>E\<^bsub>\<Gamma> \<ominus> f\<^esub> = \<^bold>E\<^bsub>\<Gamma>\<^esub>"
  "web.more (\<Gamma> \<ominus> f) = web.more \<Gamma>"

Output: by(auto simp add: minus_web_def vertex_def)


Input:
lemma env_restr_env_restr_subset:
 "d1 \<subseteq> d2 \<Longrightarrow> x f|` d2 f|` d1 = x f|` d1"

Output: by (metis Int_absorb2 env_restr_env_restr)


Input:
lemma fps_shift_times_fps_X' [simp]:
  fixes f :: "'a::{comm_monoid_add,mult_zero,monoid_mult} fps"
  shows "fps_shift 1 (f * fps_X) = f"

Output: by (intro fps_ext) (simp add: nth_less_subdegree_zero)


Input:
lemma set_orbit_list':
  assumes "permutation f" shows "set (orbit_list f x) = orbit f x"

Output:
using assms
by (simp add: permutation_self_in_orbit set_orbit_list)


Input: lemma fls_prpart_idem [simp]: "fls_prpart (fls_prpart_as_fls f) = fls_prpart f"

Output:
using fls_prpart_as_fls_nth[of f]
by (intro poly_eqI) simp


Input: lemma blinfun_apply_Pair_minus2: "blinfun_apply f (0, a - b) = blinfun_apply f (0, a) - blinfun_apply f (0, b)"

Output:
unfolding blinfun.bilinear_simps[symmetric]
by simp


Input:
lemma stable_transient_empty:
    "[| F \<in> stable A; F \<in> transient A; all_total F |] ==> A = {}"

Output:
apply (drule stable_transient, assumption)
apply (simp add: all_total_def) done


Input:
lemma rightUniqueFunctionAfterInverse:
  assumes "runiq f"
  shows "f``(f^-1``Y) \<subseteq> Y"

Output:
using assms runiq_basic ImageE converse_iff subsetI
by (metis(no_types))


Input:
lemma smallo_imp_le_real:
  assumes "f \<in> o[F](g)" "eventually (\<lambda>x. g x \<ge> (0::real)) F"
  shows   "eventually (\<lambda>x. f x \<le> g x) F"

Output:
using landau_o.smallD[OF assms(1) zero_less_one] assms(2)
by eventually_elim simp


Input:
lemma fps_unit_factor_decompose':
  "f = fps_X ^ subdegree f * unit_factor f"

Output:
using fps_unit_factor_decompose
by (simp add: fps_mult_fps_X_power_commute)


Input:
theorem constr_fp_uniq:
  assumes "constr F E" "mono F" "\<Sqinter> (range E) = C"
  shows "(C \<and> \<mu> F) = (C \<and> \<nu> F)"

Output:
using assms(1) assms(2) assms(3) chain_pred_terminates
by blast


Input:
lemma mu_below_nu:
  "has_least_fixpoint f \<Longrightarrow> has_greatest_fixpoint f \<Longrightarrow> \<mu> f \<le> \<nu> f"

Output:
using greatest_fixpoint is_greatest_fixpoint_def mu_unfold
by auto


Input:
lemma generate_topology_on_Inter:
  "\<lbrakk>finite \<F>; \<And>K. K \<in> \<F> \<Longrightarrow> generate_topology_on \<S> K; \<F> \<noteq> {}\<rbrakk> \<Longrightarrow> generate_topology_on \<S> (\<Inter>\<F>)"

Output: by (induction \<F> rule: finite_induct; force intro: generate_topology_on.intros)


Input: lemma quantale_closed_unital_maps_iff: "f \<in> quantale_closed_unital_maps = (\<forall> x y. f x \<cdot> f y \<le> f (x \<cdot> y) \<and> 1 \<le> f 1)"

Output:
unfolding quantale_closed_unital_maps_def
by clarsimp


Input:
lemma lift_trans_bigtheta:
  assumes "f \<in> L F (g)"
  assumes "(\<lambda>x. t x (g x)) \<in> \<Theta>[F](h)"
  assumes "\<And>f g. f \<in> L F (g) \<Longrightarrow> (\<lambda>x. t x (f x)) \<in> L F (\<lambda>x. t x (g x))"
  shows   "(\<lambda>x. t x (f x)) \<in> L F (h)"

Output:
using cong_bigtheta[OF assms(2)] assms(3)[OF assms(1)]
by simp


Input:
lemma has_vector_derivative_at_split:
  "(f has_vector_derivative f') (at x) \<longleftrightarrow>
   (f has_vector_derivative f') (at_left x) \<and>
   (f has_vector_derivative f') (at_right x)"

Output:
using has_derivative_at_split[of f "\<lambda>h. h *\<^sub>R f'" x]
by (simp add: has_vector_derivative_def)


Input:
lemma preserves_comp_1:
    assumes "A.seq f' f"
    shows "\<tau> (f' \<cdot>\<^sub>A f) = G f' \<cdot>\<^sub>B \<tau> f"

Output:
using assms
by (metis A.seqE A.dom_comp B.comp_assoc G.preserves_comp is_natural_1)


Input:
lemma nu_below_mu_nu_kappa_mu_nu:
  "has_least_fixpoint f \<Longrightarrow> has_greatest_fixpoint f \<Longrightarrow> isotone f \<Longrightarrow> apx.isotone f \<Longrightarrow> nu_below_mu_nu f \<Longrightarrow> kappa_mu_nu f"

Output:
using apx_meet_below_nu_kappa_mu_nu mu_nu_apx_meet_apx_meet_below_nu mu_nu_apx_nu_mu_nu_apx_meet nu_below_mu_nu_mu_nu_apx_nu
by blast


Input:
lemma gmap_eq_imp_glength_eq: "
  gmap f a = gmap f b \<Longrightarrow> glength a = glength b"

Output: by (drule arg_cong[where f=glength], simp)


Input:
lemma imageEquivalence:
  assumes "runiq (f::(('a \<times> ('b set)) set))" "x \<in> Domain f"
  shows "f,,x = f,,,x"

Output:
using assms Image_runiq_eq_eval cSup_singleton
by metis


Input:
lemma fls_residue_of_int_times:
  fixes f :: "'a::ring_1 fls"
  shows "fls_residue (of_int i * f) = of_int i * fls_residue f"
  and   "fls_residue (f * of_int i) = fls_residue f * of_int i"

Output: by (simp_all add: fls_residue_fls_const_times fls_of_int)


Input:
lemma has_integral_spike_interior:
  assumes f: "(f has_integral y) (cbox a b)" and gf: "\<And>x. x \<in> box a b \<Longrightarrow> g x = f x"
  shows "(g has_integral y) (cbox a b)"

Output: by (meson Diff_iff gf has_integral_spike[OF negligible_frontier_interval _ f])


Input:
lemma id_imp_bij_betw:
  assumes f: "f : A \<rightarrow> A"
      and ff: "\<And>a. a \<in> A \<Longrightarrow> f (f a) = a"
  shows "bij_betw f A A"

Output: by (intro bij_betwI[OF f f], simp_all add: ff)


Input:
lemma fls_subdegree_lt_fls_regpart_subdegree:
  "fls_subdegree f \<le> int (subdegree (fls_regpart f))"

Output:
using fls_subdegree_leI nth_subdegree_nonzero[of "fls_regpart f"]
by (cases "(fls_regpart f) = 0") (simp_all add: fls_regpart_eq0_imp_nonpos_subdegree)


Input:
lemma (in Network) isMaxFlow_alt:
  "isMaxFlow f \<longleftrightarrow> NFlow c s t f \<and>
    (\<forall>f'. NFlow c s t f' \<longrightarrow> Flow.val c s f' \<le> Flow.val c s f)"

Output:
unfolding isMaxFlow_def
by (auto simp: NFlow_def Flow_def NPreflow_def) intro_locales


Input: lemma conuc_Sup_closed: "conucleus f \<Longrightarrow> f \<circ> Sup \<circ> (`) f = Sup \<circ> (`) f"

Output:
unfolding conucleus_def fun_eq_iff comp_def
by (smt coclop_coextensive_var coclop_idem coclop_iso image_comp image_image le_iff_sup mono_SUP sup.orderE)


Input:
lemma linear_inj_bounded_below_pos:
  fixes f :: "'a::real_normed_vector \<Rightarrow> 'b::euclidean_space"
  assumes "linear f" "inj f"
  obtains B where "B > 0" "\<And>x. B * norm x \<le> norm(f x)"

Output:
using linear_injective_left_inverse [OF assms] linear_invertible_bounded_below_pos assms
by blast


Input:
lemma has_field_derivative_transform_within_open:
  assumes "(f has_field_derivative f') (at a)"
    and "open S" "a \<in> S"
    and "\<And>x. x \<in> S \<Longrightarrow> f x = g x"
  shows "(g has_field_derivative f') (at a)"

Output:
using assms unfolding has_field_derivative_def
by (metis has_derivative_transform_within_open)


Input:
lemma integrable_scale_measure [simp]:
  "\<lbrakk> integrable M f; r < \<top> \<rbrakk> \<Longrightarrow> integrable (scale_measure r M) f"
  for f :: "'a \<Rightarrow> 'b::{banach, second_countable_topology}"

Output: by(auto simp add: integrable_iff_bounded nn_integral_scale_measure ennreal_mult_less_top)


Input:
lemma eqvt_cases:
  fixes f x \<pi>
  assumes eqvt: "\<And>x. \<pi> \<bullet> f x = f (\<pi> \<bullet> x)"
  obtains "f x" "f (\<pi> \<bullet> x)" | "\<not> f x " " \<not> f (\<pi> \<bullet> x)"

Output:
using assms[symmetric]
by (cases "f x") auto


Input:
lemma eta[simp]:
  assumes "f \<in> elts (VPi A B)"
  shows "VLambda A ((app)f) = f"

Output:
proof (rule fun_ext [OF _ assms]) show "VLambda A (app f) \<in> elts (VPi A B)"
using VPi_D VPi_I assms
by auto
qed auto


Input:
lemma (in order_topology) decreasing_tendsto:
  assumes bdd: "eventually (\<lambda>n. l \<le> f n) F"
    and en: "\<And>x. l < x \<Longrightarrow> eventually (\<lambda>n. f n < x) F"
  shows "(f \<longlongrightarrow> l) F"

Output:
using assms
by (intro order_tendstoI) (auto elim!: eventually_mono)


Input:
lemma linf_norm_poly_greater_0 [simp]:
  fixes f :: "'a :: ordered_ab_group_add_abs poly"
  shows "\<parallel>f\<parallel>\<^sub>\<infinity> > 0 \<longleftrightarrow> f \<noteq> 0"

Output: by (induct f, auto simp: max_def)


Input:
lemma eventually_nonzero_bigtheta':
  "f \<in> \<Theta>[F](g) \<Longrightarrow> eventually_nonzero F f \<longleftrightarrow> eventually_nonzero F g"

Output:
unfolding eventually_nonzero_def
by (rule eventually_nonzero_bigtheta)


Input:
lemma expands_to_imp_eventually_lt:
  assumes "basis_wf basis" "((\<lambda>x. f x - g x) expands_to F) basis" "trimmed_neg F"
  shows   "eventually (\<lambda>x. f x < g x) at_top"

Output:
using expands_to_imp_eventually_neg[OF assms]
by simp


Input:
lemma fcontX:
  shows "continuous_on X f"

Output:
using auto_local_lipschitz local_lipschitz_continuous_on
by blast


Input:
lemma ereal_INF_not_infty:
  fixes f :: "_ \<Rightarrow> ereal"
  shows "A \<noteq> {} \<Longrightarrow> l \<noteq> -\<infinity> \<Longrightarrow> u \<noteq> \<infinity> \<Longrightarrow> \<forall>a\<in>A. l \<le> f a \<and> f a \<le> u \<Longrightarrow> \<bar>Inf (f ` A)\<bar> \<noteq> \<infinity>"

Output:
using INF_lower2[of _ A f u] INF_greatest[of A l f]
by (cases "Inf (f ` A)") auto


Input:
lemma map_poly_pCons:
  assumes "f 0 = 0"
  shows "map_poly f (pCons c p) = pCons (f c) (map_poly f p)"

Output: by (intro poly_eqI) (simp_all add: assms coeff_map_poly coeff_pCons split: nat.splits)


Input:
lemma rangeOutside:
  assumes "runiq f" "runiq (f^-1)"
  shows "Range(f outside X) = (Range f)-(f``X)"

Output:
using assms lm089 lm092
by (metis order_class.order.antisym)


Input:
lemma comm_semigroup_pair_ow[ud_with]:
  "comm_semigroup_pair = (\<lambda>f\<^sub>a f\<^sub>b. comm_semigroup_pair_ow UNIV f\<^sub>a UNIV f\<^sub>b)"

Output:
unfolding comm_semigroup_pair_def comm_semigroup_pair_ow_def ud_with
by simp


Input: lemma fmmap_fmupd: "fmmap f (fmupd x y m) = fmupd x (f y) (fmmap f m)"

Output: by transfer' (auto simp: fun_eq_iff map_upd_def)


Input:
lemma map_spmf_of_set_inj_on [simp]:
  "inj_on f A \<Longrightarrow> map_spmf f (spmf_of_set A) = spmf_of_set (f ` A)"

Output: by(auto simp add: spmf_of_set_def map_pmf_of_set_inj dest: finite_imageD)


Input:
lemma range_inj_infinite:
  fixes f :: "nat \<Rightarrow> 'a"
  assumes "inj f"
  shows "infinite (range f)"

Output:
proof assume "finite (range f)" from this assms have "finite (UNIV::nat set)"
by (rule finite_imageD) then show False
by simp
qed


Input:
lemma continuous_powr_complex:
  assumes "f (netlimit F) \<notin> \<real>\<^sub>\<le>\<^sub>0" "continuous F f" "continuous F g"
  shows   "continuous F (\<lambda>z. f z powr g z :: complex)"

Output:
using assms unfolding continuous_def
by (intro tendsto_powr_complex) simp_all


Input:
lemma lfp_to_gfp_var:
  fixes f :: "'a::complete_lattice_with_dual \<Rightarrow> 'a"
  shows "lfp f = \<partial> (gfp (\<partial>\<^sub>F f))"

Output: by (metis invol_dual_var lfp_dual_var)


Input: lemma adj_iso1: "f \<stileturn> g \<Longrightarrow> mono f"

Output:
unfolding adj_def mono_def
by (meson dual_order.refl dual_order.trans)


Input:
theorem weak_conv_imp_integral_bdd_continuous_conv:
  fixes f :: "real \<Rightarrow> 'a::{banach, second_countable_topology}"
  assumes
    "\<And>x. isCont f x" and
    "\<And>x. norm (f x) \<le> B"
  shows
    "(\<lambda> n. integral\<^sup>L (\<mu> n) f) \<longlonglongrightarrow> integral\<^sup>L M f"

Output:
using assms
by (intro weak_conv_imp_bdd_ae_continuous_conv) (auto intro!: borel_measurable_continuous_onI continuous_at_imp_continuous_on)


Input:
theorem Gibbard_Satterthwaite:
  "\<not> manipulable f \<Longrightarrow> \<forall>a.\<exists>P\<in>Prof. a = f P \<Longrightarrow> \<exists>i. dict f i"

Output:
using GS.Gibbard_Satterthwaite[of f,unfolded GS_def]
by blast


Input:
lemma smallomegaD_filterlim_at_infinity:
  assumes "f \<in> \<omega>[F](g)"
  assumes "eventually (\<lambda>x. g x \<noteq> 0) F"
  shows   "LIM x F. f x / g x :> at_infinity"

Output:
using assms
by (intro filterlim_norm_at_top_imp_at_infinity smallomegaD_filterlim_at_top_norm)


Input:
lemma GFP_unfold:
  "\<lbrakk> Mono f; f \<in> carrier L \<rightarrow> carrier L \<rbrakk> \<Longrightarrow> GFP f = f (GFP f)"

Output:
using eq_is_equal weak.GFP_weak_unfold
by auto


Input:
lemma integrable_abs[simp, intro]:
  fixes f :: "'a \<Rightarrow> real"
  assumes [measurable]: "integrable M f" shows "integrable M (\<lambda>x. \<bar>f x\<bar>)"

Output:
using assms
by (rule integrable_bound) auto


Input:
lemma runit'_naturality:
    assumes "arr f"
    shows "(f \<otimes> \<I>) \<cdot> \<r>\<^sup>-\<^sup>1[dom f] = \<r>\<^sup>-\<^sup>1[cod f] \<cdot> f"

Output:
using assms \<rho>'.naturality \<rho>'_ide_simp
by simp


Input: lemma "Q \<longrightarrow> (D \<and> F \<and> ((\<not> D) \<and> (\<not> F)))"

Output: apply (reify Ifm.simps ("((\<not> D) \<and> (\<not> F))")) oops


Input:
lemma codomains_simp:
    assumes "arr f"
    shows "codomains f = {cod f}"

Output:
using assms cod_in_codomains has_codomain_iff_arr codomain_unique
by auto


Input:
lemma infsetsum'_tendsto:
  assumes \<open>infsetsum'_converges f S\<close>
  shows \<open>((\<lambda>F. sum f F) \<longlongrightarrow> infsetsum' f S) (finite_subsets_at_top S)\<close>

Output: by (metis assms finite_subsets_at_top_neq_bot infsetsum'_converges_def infsetsum'_def tendsto_Lim)


Input: lemma fpower_Sup_subcomm: "mono f \<Longrightarrow> f \<circ> fstar f \<le> fstar f \<circ> f"

Output: by (metis (mono_tags, lifting) fun_mon.power_commutes le_INF_iff fpower_distr fpower_supdistl)


Input:
lemma linear_injective_isomorphism:
  assumes lf: "linear s1 s2 f"
    and fi: "inj f"
    and dims: "vs2.dim UNIV = vs1.dim UNIV"
  shows "\<exists>f'. linear s2 s1 f' \<and> (\<forall>x. f' (f x) = x) \<and> (\<forall>x. f (f' x) = x)"

Output:
unfolding isomorphism_expand[symmetric]
using linear_injective_imp_surjective[OF lf fi dims]
using fi left_right_inverse_eq lf linear_injective_left_inverse linear_surjective_right_inverse
by blast


Input: theorem M9: "|~ \<box>F \<longrightarrow> F \<and> \<circle>\<box>F"

Output:
using pre[OF ax1[of "F"]] pax3[of "F"]
by force


Input:
lemma set_restriction_absorb: "
  set_restriction f \<Longrightarrow> f (f A) = f A"

Output:
unfolding set_restriction_def
by fastforce


Input:
lemma src_simps [simp]:
    assumes "arr F"
    shows "Dom (src F) = E.Src (Dom F)" and "Cod (src F) = E.Src (Dom F)"
    and "Map (src F) = \<lbrace>E.Src (Dom F)\<rbrace>"

Output:
using assms src_def arr_char
by auto


Input:
lemma ass_function_Complete_set_non_associates:
  assumes f: "ass_function f"
  shows "Complete_set_non_associates (f`UNIV)"

Output:
unfolding Complete_set_non_associates_def ass_function_def
apply (rule exI[of _ f])
using f unfolding ass_function_def unfolding pairwise_def
by fast


Input:
lemma kappa_mu_nu_L_nu_below_mu_nu_L:
  "has_least_fixpoint f \<Longrightarrow> has_greatest_fixpoint f \<Longrightarrow> kappa_mu_nu_L f \<Longrightarrow> nu_below_mu_nu_L f"

Output:
using kappa_mu_nu_L_mu_nu_apx_nu_L mu_nu_apx_nu_L_nu_below_mu_nu_L
by auto


Input:
lemma Lim_transform2: "(f \<longlongrightarrow> a) F \<Longrightarrow> ((\<lambda>x. f x - g x) \<longlongrightarrow> 0) F \<Longrightarrow> (g \<longlongrightarrow> a) F"
  for a b :: "'a::real_normed_vector"

Output: by (erule Lim_transform) (simp add: tendsto_minus_cancel)


Input:
lemma(in idom) prod_mset_remove_units:
  "prod_mset F ddvd prod_mset {# f \<in># F. \<not>f dvd 1 #}"

Output:
proof(induct F) case (add f F) then show ?case
by (cases "f = 0", auto)
qed auto


Input:
lemma bigtheta_powr_nonneg' [landau_simp]:
  "eventually (\<lambda>x. (f x :: real) \<ge> 0) F \<Longrightarrow> (\<lambda>x. if f x < 0 then g x else h x) \<in> \<Theta>[F](h)"

Output: by (intro bigthetaI_cong) (auto elim!: eventually_mono)


Input: lemma integrable_cmul: "f integrable_on S \<Longrightarrow> (\<lambda>x. c *\<^sub>R f(x)) integrable_on S"

Output:
unfolding integrable_on_def
by(auto intro: has_integral_cmul)


Input:
lemma fin_maintainedI [intro]:
  assumes "\<And> F f. finite_graph F
           \<Longrightarrow> subgraph F (fst R)
           \<Longrightarrow> extensible (F,fst R) G f
           \<Longrightarrow> graph_homomorphism F G f
           \<Longrightarrow> extensible (F,snd R) G f"
  shows "fin_maintained R G"

Output:
using assms unfolding fin_maintained_def
by auto


Input:
lemma Zp_continuous_is_Zp_closed:
  assumes "is_Zp_continuous f"
  shows "f \<in> carrier (Fun Zp)"

Output:
using assms is_Zp_continuous_def
by blast


Input:
lemma mono_upclosed_iff:
  fixes f :: "'a::order_with_dual \<Rightarrow> 'b::order_with_dual"
  shows "mono f = (\<forall>Y. upclosed_set Y \<longrightarrow> upclosed_set (f -` Y))"

Output:
using mono_upclosed upclosed_mono
by auto


Input:
lemma elliptic_isometryD:
  assumes "elliptic_isometry f"
  shows "bounded {(f^^n) x |n. True}"
        "isometry f"

Output:
using assms unfolding elliptic_isometry_def
by auto


Input:
lemma continuous_within_compose3:
  "isCont g (f x) \<Longrightarrow> continuous (at x within s) f \<Longrightarrow> continuous (at x within s) (\<lambda>x. g (f x))"

Output:
using continuous_at_imp_continuous_at_within continuous_within_compose2
by blast


Input:
lemma tendsto_zero_powrI:
  assumes "(f \<longlongrightarrow> (0::real)) F" "(g \<longlongrightarrow> b) F" "\<forall>\<^sub>F x in F. 0 \<le> f x" "0 < b"
  shows "((\<lambda>x. f x powr g x) \<longlongrightarrow> 0) F"

Output:
using tendsto_powr2[OF assms]
by simp


Input: lemma nucleus_alt_def_cor1: "nucleus f \<Longrightarrow> f (x \<rightarrow> y) \<le> x \<rightarrow> f y"

Output: by (metis bres_galois bres_iso clop_extensive_var fres_galois nucleus_alt_def2 nucleus_def)


Input:
lemma fls_base_factor_to_fps_base_factor:
  "fls_base_factor_to_fps (fls_base_factor f) = fls_base_factor_to_fps f"

Output:
using fls_base_factor_to_fps_shift
by simp


Input:
lemma(in UP_ring) lcoeff_Lcf:
  assumes "f \<in> carrier P"
  shows "lcoeff f = lcf f"

Output:
unfolding P_def
using assms coeff_simp[of f]
by metis


Input:
lemma assumes "!!x y::'a::wn. x \<le> y \<Longrightarrow> f x \<le> f y"
and "x \<le> f x" and "\<not> f x \<le> x" and "f(f x) \<le> f x"
shows "f(x \<nabla> f x) \<le> x \<nabla> f x"

Output: nitpick[card = 4, expect = genuine, show_consts, timeout = 120] oops


Input:
lemma pmu_below_pnu_fix:
  "has_fixpoint f \<Longrightarrow> has_least_prefixpoint f \<Longrightarrow> has_greatest_postfixpoint f \<Longrightarrow> p\<mu> f \<le> p\<nu> f"

Output: by (metis greatest_postfixpoint has_fixpoint_def is_fixpoint_def is_greatest_postfixpoint_def is_least_prefixpoint_def least_prefixpoint order_refl order_trans)


Input:
lemma has_derivative_iff_norm:
  "(f has_derivative f') (at x within s) \<longleftrightarrow>
    bounded_linear f' \<and> ((\<lambda>y. norm ((f y - f x) - f' (y - x)) / norm (y - x)) \<longlongrightarrow> 0) (at x within s)"

Output:
using tendsto_norm_zero_iff[of _ "at x within s", where 'b="'b", symmetric]
by (simp add: has_derivative_at_within divide_inverse ac_simps)


Input:
lemma big_prod_in_1:
  assumes "\<And>x. x \<in> A \<Longrightarrow> f x \<in> L F (\<lambda>_. 1)"
  shows   "(\<lambda>y. \<Prod>x\<in>A. f x y) \<in> L F (\<lambda>_. 1)"

Output:
using assms
by (induction A rule: infinite_finite_induct) (auto intro!: big.mult_in_1)


Input:
lemma integral_split:
  fixes f :: "'a::euclidean_space \<Rightarrow> 'b::{real_normed_vector,complete_space}"
  assumes f: "f integrable_on (cbox a b)"
      and k: "k \<in> Basis"
  shows "integral (cbox a b) f =
           integral (cbox a b \<inter> {x. x\<bullet>k \<le> c}) f +
           integral (cbox a b \<inter> {x. x\<bullet>k \<ge> c}) f"

Output:
using k f
by (auto simp: has_integral_integral intro: integral_unique [OF has_integral_split])


Input:
lemma cod_char:
    shows "cod f = (if arr f then MkIde (Cod f) else None)"

Output:
using cod_def in_codomains_char cod_in_codomains has_codomain_iff_arr
by auto


Input:
lemma ereal_SUP_not_infty:
  fixes f :: "_ \<Rightarrow> ereal"
  shows "A \<noteq> {} \<Longrightarrow> l \<noteq> -\<infinity> \<Longrightarrow> u \<noteq> \<infinity> \<Longrightarrow> \<forall>a\<in>A. l \<le> f a \<and> f a \<le> u \<Longrightarrow> \<bar>Sup (f ` A)\<bar> \<noteq> \<infinity>"

Output:
using SUP_upper2[of _ A l f] SUP_least[of A f u]
by (cases "Sup (f ` A)") auto


Input:
lemma integral_on_1_eq:
  fixes f :: "'a::euclidean_space \<Rightarrow> real^1"
  shows "integral S f = vec (integral S (\<lambda>x. f x $ 1))"

Output: by (cases "f integrable_on S") (simp_all add: integrable_on_1_iff vec_eq_iff not_integrable_integral)


Input:
lemma linear_continuous_compose:
  fixes f :: "'a::euclidean_space \<Rightarrow> 'b::euclidean_space" and g :: "'b \<Rightarrow> 'c::real_normed_vector"
  assumes "continuous F f" "linear g"
  shows "continuous F (\<lambda>x. g(f x))"

Output:
using assms unfolding continuous_def
by (rule Lim_linear)


Input:
lemma integral_combine_division_topdown:
  fixes f :: "'n::euclidean_space \<Rightarrow> 'a::banach"
  assumes "f integrable_on S"
    and "\<D> division_of S"
  shows "integral S f = sum (\<lambda>i. integral i f) \<D>"

Output:
using assms has_integral_combine_division_topdown
by blast


Input:
lemma lm079:
  assumes "x \<in> Domain f" "runiq f"
  shows "{x}\<times>f``{x} = {(x,f,,x)}"

Output:
using assms lm078 Image_runiq_eq_eval
by metis


Input:
lemma semigroup_pair_ow[ud_with]:
  "semigroup_pair = (\<lambda>f\<^sub>a f\<^sub>b. semigroup_pair_ow UNIV f\<^sub>a UNIV f\<^sub>b)"

Output:
unfolding semigroup_pair_def semigroup_pair_ow_def ud_with
by simp


Input: lemma bigthetaI [intro]: "f \<in> O[F](g) \<Longrightarrow> f \<in> \<Omega>[F](g) \<Longrightarrow> f \<in> \<Theta>[F](g)"

Output:
unfolding bigtheta_def bigomega_def
by blast


Input:
theorem F'map_cong: "\<lbrakk>\<And>z. z \<in> F'set1 x \<Longrightarrow> f1 z = g1 z; \<And>z. z \<in> F'set2 x \<Longrightarrow> f2 z = g2 z; \<And>z. z \<in> F'set3 x \<Longrightarrow> f3 z = g3 z\<rbrakk>
  \<Longrightarrow> F'map f1 f2 f3 x = F'map g1 g2 g3 x"

Output:
apply (rule F.map_cong0)
apply assumption+ done


Input:
lemma simple_function_iff_borel_measurable:
  fixes f :: "'a \<Rightarrow> 'x::{t2_space}"
  shows "simple_function M f \<longleftrightarrow> finite (f ` space M) \<and> f \<in> borel_measurable M"

Output: by (metis borel_measurable_simple_function simple_functionD(1) simple_function_borel_measurable)


Input:
lemma trans_lfp:
  assumes "mono f" and "\<And>R. trans R \<Longrightarrow> trans (f R)"
  shows "trans (lfp f)"

Output: by (metis lfp_chain_induct[of f trans] assms trans_Sup_of_chain)


Input:
lemma (in first_countable_topology) eventually_nhds_iff_sequentially:
  "eventually P (nhds a) \<longleftrightarrow> (\<forall>f. f \<longlonglongrightarrow> a \<longrightarrow> eventually (\<lambda>n. P (f n)) sequentially)"

Output:
using eventually_nhds_within_iff_sequentially[of P a UNIV]
by simp


Input:
lemma the_inv_into_f_im_f_im:
  assumes "inj_on f A" "x\<subseteq>A"
  shows   "the_inv_into A f ` f ` x = x"

Output:
using assms(2) the_inv_into_f_f[OF assms(1)]
by force


Input:
lemma (in Group) im_d_gchainTr1:"\<lbrakk>d_gchain G n f;
       f l \<in> (f ` {i. i \<le> n}) - {f 0}\<rbrakk> \<Longrightarrow>
    f (LEAST j. f j \<in> (f ` {i. i \<le> n}) - {f 0}) \<in> (f ` {i. i \<le> n} - {f 0})"

Output:
apply (rule LeastI)
apply simp done


Input:
lemma continuous_powr:
  assumes "continuous F f"
    and "continuous F g"
    and "f (Lim F (\<lambda>x. x)) \<noteq> 0"
  shows "continuous F (\<lambda>x. (f x) powr (g x :: real))"

Output:
using assms unfolding continuous_def
by (rule tendsto_powr)


Input:
lemma lfp_in_Fix:
  fixes f :: "'a::complete_lattice \<Rightarrow> 'a"
  shows "mono f \<Longrightarrow> lfp f \<in> Fix f"

Output: by (metis (mono_tags, lifting) Fix_def lfp_unfold mem_Collect_eq)


Input:
lemma Liminf_ereal_mult_left:
  assumes "F \<noteq> bot" "(c::real) \<ge> 0"
    shows "Liminf F (\<lambda>n. ereal c * f n) = ereal c * Liminf F f"

Output:
using Liminf_ereal_mult_right[OF assms]
by (subst (1 2) mult.commute)


Input:
lemma cancel_semigroup_pair_ow[ud_with]:
  "cancel_semigroup_pair = (\<lambda>f\<^sub>a f\<^sub>b. cancel_semigroup_pair_ow UNIV f\<^sub>a UNIV f\<^sub>b)"

Output:
unfolding cancel_semigroup_pair_def cancel_semigroup_pair_ow_def ud_with
by simp


Input:
lemma flip_altsublist_adjacent_lists:
  "ss \<in> lists S \<Longrightarrow> flip_altsublist_adjacent ss ts \<Longrightarrow> ts \<in> lists S"

Output:
using flip_altsublist_adjacent_set
by fast


Input:
lemma b_e_type_grow_memory:
  assumes "\<C> \<turnstile> [e] : (ts _> ts')"
          "e = Grow_memory"
  shows "\<exists>ts''. ts = ts''@[T_i32] \<and> ts = ts' \<and> (\<exists>n. (memory \<C>) = Some n)"

Output:
using assms
by (induction "[e]" "(ts _> ts')" arbitrary: ts ts' rule: b_e_typing.induct) auto


Input:
lemma meval_MPred: "meval n t db (MPred e ts) = ([Option.these
  ((map_option (\<lambda>f. tabulate f 0 n) o match ts) ` (\<Union>(e', x)\<in>db. if e = e' then {x} else {}))], MPred e ts)"

Output: unfolding meval.simps image_these image_image o_def ..


Input:
lemma invar_merge[simp]:
  assumes "invar ts\<^sub>1"
  assumes "invar ts\<^sub>2"
  shows "invar (merge ts\<^sub>1 ts\<^sub>2)"

Output:
using assms
by (induction ts\<^sub>1 ts\<^sub>2 rule: merge.induct) (auto 0 3 simp: Suc_le_eq intro!: invar_ins_tree invar_link elim!: merge_rank_bound)


Input:
lemma matchs:
  assumes "matchs pats ts = Some env" "list_all P ts"
  shows "fmpred (\<lambda>_. P) env"

Output:
using assms
by (induction pats ts arbitrary: env rule: matchs.induct) (auto elim!: option_bindE intro: match)


Input: lemma kernel_foldl_At[simp]: "(s \<bullet>\<bullet> ts)! = (s!) \<bullet>\<bullet> (map kernelt ts)"

Output: by (induct ts arbitrary: s) simp_all


Input:
lemma b_e_type_drop:
  assumes "\<C> \<turnstile> [e] : (ts _> ts')"
          "e = Drop"
  shows "\<exists>t. ts = ts'@[t]"

Output:
using assms b_e_type_testop_drop_cvt0
by (induction "[e]" "(ts _> ts')" arbitrary: ts ts' rule: b_e_typing.induct, auto)


Input:
lemma (in valid_reads) valid_reads_nth_update:
          "\<lbrakk>i < length ts; reads_consistent False \<O> m sb \<rbrakk> \<Longrightarrow>
            valid_reads m (ts[i := (p,is,xs,sb,\<D>,\<O>,\<R>)])"

Output: by (unfold_locales) (auto dest: valid_reads simp add: nth_list_update split: if_split_asm)


Input:
lemma init_fin_descend_thr_None_conv [simp]:
  "ts t = None \<Longrightarrow> init_fin_descend_thr ts t = None"

Output: by(simp add: init_fin_descend_thr_def)


Input:
lemma b_e_type_nop:
  assumes "\<C> \<turnstile> [e] : (ts _> ts')"
          "e = Nop"
  shows "ts = ts'"

Output:
using assms
by (induction "[e]" "(ts _> ts')" arbitrary: ts ts' rule: b_e_typing.induct, auto)


Input:
lemma lift_foldl_At[simp]:
  "lift k (s \<bullet>\<bullet> ts) = (lift k s) \<bullet>\<bullet> (map (lift k) ts)"

Output: by(induct ts arbitrary:s) simp_all


Input:
theorem (in xvalid_program_progress) store_buffer_execution_result_sequential_consistent'_hol:
"(ts\<^sub>s\<^sub>b,m,x) \<Rightarrow>\<^sub>s\<^sub>b\<^sup>* (ts\<^sub>s\<^sub>b',m',x') \<and>
empty_store_buffers ts\<^sub>s\<^sub>b' \<and>
ts\<^sub>s\<^sub>b \<sim>\<^sub>d ts \<and>
initial\<^sub>v ts \<S> valid \<and>
safe_reach_virtual safe_free_flowing (ts,m,\<S>)
\<longrightarrow>
(\<exists>ts' \<S>'.
          (ts,m,\<S>) \<Rightarrow>\<^sub>v\<^sup>* (ts',m',\<S>') \<and> ts\<^sub>s\<^sub>b' \<sim>\<^sub>d ts')"

Output:
apply clarify
apply (drule store_buffer_execution_result_sequential_consistent')
apply auto done


Input:
lemma sees_method_fun:
  "\<lbrakk>P \<turnstile> C sees M:TS\<rightarrow>T = m in D; P \<turnstile> C sees M:TS'\<rightarrow>T' = m' in D' \<rbrakk>
   \<Longrightarrow> TS' = TS \<and> T' = T \<and> m' = m \<and> D' = D"

Output: by(fastforce dest: sees_methods_fun simp:Method_def)


Input:
lemma depth_At_foldl:
 "depth_At(s \<bullet>\<bullet> ts) = depth_At s + size ts"

Output: by (induct ts arbitrary: s) simp_all


Input:
lemma backwards_c_res_stab:
  "(ts \<^bold>\<midarrow>c(d,n) \<^bold>\<rightarrow> ts') \<and> (ts',v \<Turnstile> re(c)) \<longrightarrow> (ts,v \<Turnstile> re(c))"

Output:
using create_claim_length_stable traffic.create_clm_eq_res
by (metis (mono_tags, lifting) traffic.create_claim_def)


Input: lemma taints_wellformedness: "untaints ts \<subseteq> taints ts"

Output:
using raw_of_taints taints_def untaints_def
by auto


Input:
lemma HPT_HADelta:
   " \<lbrakk> TS \<in> HPT ST; t \<in> TS \<rbrakk> \<Longrightarrow> t \<in> HADelta (HA ST)"

Output:
apply (rule ET_HADelta)
apply (unfold HPT_def MaxNonConflict_def)
apply auto done


Input:
lemma redT_updTs_Some:
  "\<lbrakk> ts t = \<lfloor>xw\<rfloor>; thread_oks ts tas \<rbrakk> \<Longrightarrow> redT_updTs ts tas t = \<lfloor>xw\<rfloor>"

Output: by(induct ts tas rule: redT_updTs.induct)(auto intro: redT_updT_Some)


Input:
lemma lock_thread_ok_has_lockE:
  assumes "lock_thread_ok ls ts"
  and "has_lock (ls $ l) t"
  obtains x ln' where "ts t = \<lfloor>(x, ln')\<rfloor>"

Output:
using assms
by(auto dest!: lock_thread_okD)


Input:
lemma L1_Boiler:
  assumes "SteamBoiler x s y"
         and "ts x"
  shows "ts s"

Output:
using assms
by (simp add: SteamBoiler_def)


Input: lemma pure_foldl_At[simp]: "pure(s \<bullet>\<bullet> ts) \<longleftrightarrow> pure s \<and> (\<forall>t\<in>set ts. pure t)"

Output: by(induct ts arbitrary: s) auto


Input:
lemma redT_updTs'_eq_None_conv:
  "(\<And>t. ts t = None \<longleftrightarrow> ts' t = None) \<Longrightarrow> redT_updTs' ts tas t = None \<longleftrightarrow> redT_updTs ts' tas t = None"

Output:
apply(induct tas arbitrary: ts ts')
apply simp_all
apply(blast intro: redT_updT'_eq_None_conv del: iffI) done


Input:
lemma is_bintree_list_length [simp]:
  "is_bintree_list l ts \<Longrightarrow> length ts = l"

Output: by (erule is_bintree_list.induct) simp_all


Input:
lemma external_WT'_iff:
  "P,h \<turnstile> a\<bullet>M(vs) : U \<longleftrightarrow>
  (\<exists>hT Ts Ts' D. typeof_addr h a = \<lfloor>hT\<rfloor> \<and> map typeof\<^bsub>h\<^esub> vs = map Some Ts \<and> P \<turnstile> class_type_of hT sees M:Ts'\<rightarrow>U=Native in D \<and> P \<turnstile> Ts [\<le>] Ts')"

Output: by(simp add: external_WT'.simps)


Input:
lemma invar_del_min[simp]:
  assumes "ts \<noteq> []"
  assumes "invar ts"
  shows "invar (del_min ts)"

Output:
using assms unfolding del_min_def
by (auto split: prod.split tree.split intro!: invar_merge invar_children dest: invar_get_min_rest )


Input:
lemma threads_ok_init_fin_descend_thr [simp]:
  "thread_oks (init_fin_descend_thr ts) ntas = thread_oks ts ntas"

Output: by(induct ntas arbitrary: ts)(auto elim!: thread_oks_ts_change[THEN iffD1, rotated 1])


Input: lemma liftrT_assoc_Some: "fs\<langle>l\<rangle>\<^sub>? = \<lfloor>T\<rfloor> \<Longrightarrow> \<up>\<^sub>r\<^sub>\<tau> n k fs\<langle>l\<rangle>\<^sub>? = \<lfloor>\<up>\<^sub>\<tau> n k T\<rfloor>"

Output: by (induct fs rule: list.induct) auto


Input:
lemma mfinalE:
  fixes ln
  assumes "mfinal s" "thr s t = \<lfloor>(x, ln)\<rfloor>"
  obtains "final x" "ln = no_wait_locks" "wset s t = None"

Output:
using mfinalD[OF assms]
by(rule that)


Input: lemma assumes "\<exists>x. \<^bold>\<not>(E x)" shows True

Output: nitpick [satisfy] oops \<comment> \<open>Consistency\<close>


Input:
lemma deadlocked_thread_exists:
  assumes "t \<in> deadlocked s"
  and "\<And>x ln. thr s t = \<lfloor>(x, ln)\<rfloor> \<Longrightarrow> thesis"
  shows thesis

Output:
using assms
by cases blast+


Input:
lemma wset_final_okE:
  assumes "wset_final_ok ws ts" "ws t = \<lfloor>w\<rfloor>"
  and "\<And>x ln. ts t = \<lfloor>(x, ln)\<rfloor> \<Longrightarrow> \<not> final x \<Longrightarrow> thesis"
  shows thesis

Output:
using assms
by(blast dest: wset_final_okD)


Input:
lemma fixes e :: "('a,'b,'addr) exp" and es :: "('a,'b,'addr) exp list"
  shows inline_call_max_vars: "call e = \<lfloor>aMvs\<rfloor> \<Longrightarrow> max_vars (inline_call e' e) \<le> max_vars e + max_vars e'"
  and inline_calls_max_varss: "calls es = \<lfloor>aMvs\<rfloor> \<Longrightarrow> max_varss (inline_calls e' es) \<le> max_varss es + max_vars e'"

Output: by(induct e and es rule: call.induct calls.induct)(auto)


Input:
lemma has_field_derivative_rGamma_complex' [derivative_intros]:
  "(rGamma has_field_derivative (if z \<in> \<int>\<^sub>\<le>\<^sub>0 then (-1)^(nat \<lfloor>-Re z\<rfloor>) * fact (nat \<lfloor>-Re z\<rfloor>) else
        -rGamma z * Digamma z)) (at z within A)"

Output:
using has_field_derivative_rGamma[of z]
by (auto elim!: nonpos_Ints_cases')


Input:
lemma fixes e :: "('a, 'b, 'addr) exp" and es :: "('a, 'b, 'addr) exp list"
  shows call1_imp_call: "call1 e = \<lfloor>aMvs\<rfloor> \<Longrightarrow> call e = \<lfloor>aMvs\<rfloor>"
  and calls1_imp_calls: "calls1 es = \<lfloor>aMvs\<rfloor> \<Longrightarrow> calls es = \<lfloor>aMvs\<rfloor>"

Output: by(induct e and es rule: call1.induct calls1.induct) auto


Input: lemma None_Boolean_def : "(None::('\<AA>)Boolean) = (\<lambda> \<tau>. \<lfloor>\<bottom>\<rfloor>)"

Output: by(simp add: None_fun_def None_option_def bot_option_def)


Input:
lemma boundOutputFresh:
  fixes x    :: name
  and   xvec :: "name list"
  and   B   :: "('a::fs_name, 'b::fs_name, 'c::fs_name) boundOutput"

  shows "(x \<sharp> (\<lparr>\<nu>*xvec\<rparr>B)) = (x \<in> set xvec \<or> x \<sharp> B)"

Output: by (induct xvec) (simp_all add: abs_fresh)


Input: lemma indiff_set_mono: "indiff_set S A \<Longrightarrow> B \<subseteq> A \<Longrightarrow> B \<noteq> {} \<Longrightarrow> indiff_set S B"

Output:
unfolding indiff_set_def
by blast


Input:
lemma is_natural_transformation:
    shows "natural_transformation A B F.map G.map map"

Output:
apply unfold_locales
using map_def value_is_arr B.comp_arr_dom B.comp_cod_arr
by auto


Input:
lemma lcm_proj1_if_dvd:
  assumes "b dvd a" shows "lcm a b = normalize a"

Output:
proof - have "normalize (lcm a b) = normalize a"
by (rule associatedI) (use assms in auto) thus ?thesis
by simp
qed


Input:
lemma set_less_eq_aux''_total:
  "\<lbrakk> A \<in> infinite_complement_partition; B \<in> infinite_complement_partition \<rbrakk>
  \<Longrightarrow> A \<sqsubseteq>''' B \<or> B \<sqsubseteq>''' A"

Output:
using set_less_eq_aux''_linear_order
by(auto simp add: linear_order_on_def dest: total_onD)


Input:
lemma inv_end5_exit_Bk_Oc_via_loop[elim]:
  "\<lbrakk>0 < x; inv_end5_loop x (b, Oc # list); b \<noteq> []; hd b = Bk\<rbrakk> \<Longrightarrow>
  inv_end5_exit x (tl b, Bk # Oc # list)"

Output:
apply(auto simp: inv_end5_loop.simps inv_end5_exit.simps)
using hd_replicate
apply fastforce
by (metis cell.distinct(1) hd_append2 hd_replicate list.sel(3) self_append_conv2 split_head_repeat(2))


Input:
lemma ucast_down_mult:
    "is_down (ucast:: 'a word \<Rightarrow> 'b word) \<Longrightarrow>  ucast ((a :: 'a::len word) * b) = (ucast a * ucast b :: 'b::len word)"

Output:
apply (rule ucast_distrib [where L="(*)"], (clarsimp simp: uint_word_ariths)+)
apply (metis mod_mult_eq)
apply simp done


Input: lemma subset_insertD: "A \<subseteq> insert x B \<Longrightarrow> A \<subseteq> B \<and> x \<notin> A \<or> (\<exists>B'. A = insert x B' \<and> B' \<subseteq> B)"

Output:
apply (case_tac "x \<in> A")
apply (rule disjI2)
apply (rule_tac x = "A - {x}" in exI)
apply fast+ done


Input:
lemma widen_antisym [trans]:
  assumes a_b: "a \<preceq> b"
  assumes b_c: "b \<preceq> a"
  shows "a = b"

Output:
using a_b b_c antisym_rtrancl_direct_subtype
by (unfold antisym_def) blast


Input:
lemma cert_okD3 [intro?]:
  "cert_ok c n T B A \<Longrightarrow> B \<in> A \<Longrightarrow> pc < n \<Longrightarrow> c!Suc pc \<in> A"

Output: by (drule Suc_leI) (auto simp add: le_eq_less_or_eq dest: cert_okD1 cert_okD2)


Input:
lemma measure_count_space[simp]:
  "B \<subseteq> A \<Longrightarrow> finite B \<Longrightarrow> measure (count_space A) B = card B"

Output:
unfolding measure_def
by (subst emeasure_count_space ) auto


Input:
lemma set_less_eq_aux_infinite_complement_partitionD:
  "A \<sqsubseteq>' B \<Longrightarrow> A \<in> infinite_complement_partition \<and> B \<in> infinite_complement_partition"

Output: by(auto simp add: set_less_eq_aux_def dest: set_less_aux_finiteD intro: finite_complement_partition)


Input:
lemma (in Order) gt_than_any_outside:"\<lbrakk>A \<subseteq> carrier D; b \<in> carrier D;
       \<forall>x\<in>A. x \<prec> b\<rbrakk> \<Longrightarrow> b \<notin> A"

Output:
apply (rule contrapos_pp, simp+)
apply (frule_tac x = b in bspec)
apply (assumption, thin_tac "\<forall>x\<in>A. x \<prec> b", simp add:oless_def) done


Input: lemma Melem_subst_atm_mset[simp]: "A \<in># AA \<cdot>am \<sigma> \<longleftrightarrow> (\<exists>B. B \<in># AA \<and> A = B \<cdot>a \<sigma>)"

Output:
unfolding subst_atm_mset_def
by auto


Input:
lemma tm_append_fetch_first:
  "\<lbrakk>fetch A s b = (ac, ns); ns \<noteq> 0\<rbrakk> \<Longrightarrow>
    fetch (A @ B) s b = (ac, ns)"

Output: by(cases b;cases s;force simp: fetch.simps nth_append split: if_splits)


Input: lemma still_reachable_eq: "\<lbrakk> A\<subseteq>Rb\<^sup>*``B; B\<subseteq>Ra\<^sup>*``A; \<forall> (x,y) \<in> Ra-Rb. y \<in>(Rb\<^sup>*``B); \<forall> (x,y) \<in> Rb-Ra. y\<in> (Ra\<^sup>*``A)\<rbrakk> \<Longrightarrow> Ra\<^sup>*``A =  Rb\<^sup>*``B "

Output:
apply (rule equalityI)
apply (erule still_reachable ,assumption)+ done


Input:
lemma in_open_segment_rotD:
  "x \<in> {a<--<b} \<Longrightarrow> (x - a) \<bullet> rot (b - a) = 0 \<and> x \<bullet> (b - a) \<in> {a\<bullet>(b - a) <..< b \<bullet> (b - a)}"

Output: by (subst in_open_segment_iff_rot[symmetric]) auto


Input: lemma minus_lt: "(a::'a) < b \<longleftrightarrow> a - b < 0"

Output:
using plus_less[of a b "-b"]
using plus_less[of "a - b" 0 b]
by (auto simp add: add_assoc)


Input:
lemma IF_simps [simp]:
  "defined b \<Longrightarrow> \<lbrakk> b \<rbrakk> \<Longrightarrow> (If b then x else y) = x"
  "defined b \<Longrightarrow> \<lbrakk> b \<rbrakk> = False \<Longrightarrow> (If b then x else y) = y"

Output: by (cases b, simp_all)+


Input: lemma Sep_Cl_diff: "Der_1b \<D> \<Longrightarrow> \<forall>A B. Cl(A) \<and> Cl(B) \<longrightarrow> Sep (A \<^bold>\<leftharpoonup> B) (B \<^bold>\<leftharpoonup> A)"

Output:
unfolding Sep_def
using CD1b PD1 bottom_def diff_def meet_def
by smt


Input:
lemma ivt_decreasing_component_on_1:
  fixes f :: "real \<Rightarrow> 'a::euclidean_space"
  assumes "a \<le> b"
    and "continuous_on {a..b} f"
    and "(f b)\<bullet>k \<le> y"
    and "y \<le> (f a)\<bullet>k"
  shows "\<exists>x\<in>{a..b}. (f x)\<bullet>k = y"

Output:
using ivt_increasing_component_on_1[of a b "\<lambda>x. - f x" k "- y"] neg_equal_iff_equal
using assms continuous_on_minus
by force


Input:
lemma merge_on_subset:
  "B \<subseteq> A \<Longrightarrow> merge_on B h bo m"

Output: by unfold_locales (auto dest: same join undefined)


Input:
lemma to_nat_inj[simp]: assumes "to_nat a = to_nat b"
  shows "a = b"

Output:
proof - from to_nat_ex[of a] to_nat_ex[of b] show "a = b" unfolding to_nat_def
by (metis assms from_nat_to_nat_id)
qed


Input:
lemma
  "fst (hd [(a, b)]) = a"
  "snd (hd [(a, b)]) = b"

Output:
using fst_conv snd_conv prod.collapse list.sel(1,3)
using [[smt_oracle, z3_extensions]]
by smt+


Input:
lemma sint_numeral:
  "sint (numeral b :: 'a::len word) =
    (numeral b + 2 ^ (LENGTH('a) - 1)) mod 2 ^ LENGTH('a) - 2 ^ (LENGTH('a) - 1)"

Output: by (metis int_word_sint word_numeral_alt)


Input: lemma tl_conc[simp]: "[] \<notin> A \<Longrightarrow>tl ` (A @@ B) = tl ` A @@ B"

Output: by (fastforce simp: image_def Bex_def tl_append split: list.split)


Input: lemma bounded_clinear_left: "bounded_clinear (\<lambda>a. a ** b)"

Output:
proof - obtain K where "\<And>a b. norm (a ** b) \<le> norm a * norm b * K"
using pos_bounded
by blast then show ?thesis
by (rule_tac K="norm b * K" in bounded_clinear_intro) (auto simp: algebra_simps scaleC_left add_left)
qed


Input:
lemma Abs_swap2:
  assumes a1: "a \<notin> (supp x) - (set bs)"
  and     a2: "b \<notin> (supp x) - (set bs)"
  shows "[bs]lst. x = [(a \<rightleftharpoons> b) \<bullet> bs]lst. ((a \<rightleftharpoons> b) \<bullet> x)"

Output:
unfolding Abs_eq_iff unfolding alphas unfolding supp_eqvt[symmetric] Diff_eqvt[symmetric] set_eqvt[symmetric] unfolding fresh_star_def fresh_def unfolding swap_set_not_in[OF a1 a2]
using a1 a2
by (rule_tac [!] x="(a \<rightleftharpoons> b)" in exI) (auto simp: supp_perm swap_atom)


Input:
lemma mset_set_Union:
  "finite A \<Longrightarrow> finite B \<Longrightarrow> A \<inter> B = {} \<Longrightarrow> mset_set (A \<union> B) = mset_set A + mset_set B"

Output: by (induction A rule: finite_induct) auto


Input: lemma vdunion_vsum: "(\<Coprod>\<^sub>\<times>i\<in>\<^sub>\<circ>set{0, 1}. if i=0 then A else B) = A \<Uplus> B"

Output:
unfolding vdunion_vdoubleton vsum_def
by simp


Input:
lemma card_bijections_range_permutation:
  assumes "finite A" "finite B"
  shows "card ({f \<in> A \<rightarrow>\<^sub>E B. bij_betw f A B} // range_permutation A B) = iverson (card A = card B)"

Output:
using assms card_bijections_range_permutation_eq_0 card_bijections_range_permutation_eq_1 unfolding iverson_def
by auto


Input: lemma Im_complex_div_lt_0: "Im (a / b) < 0 \<longleftrightarrow> Im (a * cnj b) < 0"

Output: by (metis Im_complex_div_eq_0 Im_complex_div_gt_0 less_asym neq_iff)


Input:
lemma less_min_eq1:
  "(a :: 'a :: order) < b \<Longrightarrow> min a b = a"

Output: by(auto simp add: min_def order_less_imp_le)


Input:
lemma points_index_block_image_add_eq:
  assumes "x \<notin> ps"
  assumes "B index ps = l"
  shows "{# insert x b . b \<in># B#} index ps = l"

Output:
using points_index_def
by (metis (no_types, lifting) assms filter_mset_cong image_mset_filter_swap2 points_index_def size_image_mset subset_insert)


Input:
lemma qo_on_subset:
  "A \<subseteq> B \<Longrightarrow> qo_on P B \<Longrightarrow> qo_on P A"

Output:
unfolding qo_on_def
using reflp_on_subset and transp_on_subset
by blast


Input:
lemma has_integral_componentwise:
  fixes f :: "'a :: euclidean_space \<Rightarrow> 'b :: euclidean_space"
  shows "(\<And>b. b \<in> Basis \<Longrightarrow> ((\<lambda>x. f x \<bullet> b) has_integral (y \<bullet> b)) A) \<Longrightarrow> (f has_integral y) A"

Output: by (subst has_integral_componentwise_iff) blast


Input:
lemma rel_fset_image:
  assumes "rel_fset P A B"
  assumes "\<And>a b. a |\<in>| A \<Longrightarrow> b |\<in>| B \<Longrightarrow> P a b \<Longrightarrow> Q (f a) (g b)"
  shows "rel_fset Q (f |`| A) (g |`| B)"

Output:
using assms
by transfer' (rule rel_set_image)


Input:
lemma rtrancl_on_rtranclI:
  "(a,b) \<in> rtrancl_on F r \<Longrightarrow> (a,b) \<in> r\<^sup>*"

Output: by (induct rule: rtrancl_on_induct) simp_all


Input: lemma epred_min [simp]: "epred (min a b) = min (epred a) (epred b)"

Output: by(cases a b rule: enat_coexhaust[case_product enat_coexhaust]) simp_all


Input: lemma vector_mul_rcancel[simp]: "a *s x = b *s x \<longleftrightarrow> (a::'a::field) = b \<or> x = 0"

Output: by (subst eq_iff_diff_eq_0, subst vector_sub_rdistrib [symmetric]) simp


Input:
lemma sqmatrix_add_commute [simp]:
  "(A::('a::ab_semigroup_add,'m) sqmatrix) + B = B + A"

Output: by (cases A, cases B, simp add: add.commute)


Input: lemma compute_float_less[code]: "a < b \<longleftrightarrow> is_float_pos (float_plus_down 0 b (- a))"

Output:
using truncate_down[of 0 "b - a"] truncate_down_pos[of "b - a" 0]
by transfer (auto simp: plus_down_def)


Input:
lemma
  "fst (hd [(a, b)]) = a"
  "snd (hd [(a, b)]) = b"

Output:
using fst_conv snd_conv prod.collapse list.sel(1,3)
using [[smt_oracle, z3_extensions]]
by smt+


Input:
lemma zdiv_le_dividend:
  \<open>0 \<le> a \<Longrightarrow> 0 < b \<Longrightarrow> a div b \<le> a\<close> for a b :: int

Output: by (metis div_by_1 int_one_le_iff_zero_less zdiv_mono2 zero_less_one)


Input:
lemma div_reals [simp]:
  assumes "is_real a" and "is_real b"
  shows "is_real (a / b)"

Output:
using assms
by (simp add: complex_is_Real_iff)


Input:
lemma vec_le_iff_diff_le_0: fixes a :: "'a :: ordered_ab_group_add vec"
  shows "(a \<le> b) = (a - b \<le> 0\<^sub>v (dim_vec a))"

Output:
unfolding less_eq_vec_def
by auto


Input: lemma ennreal_zero_less_divide: "0 < a / b \<longleftrightarrow> (0 < a \<and> b < (top::ennreal))"

Output:
unfolding divide_ennreal_def
by transfer (auto simp: ereal_zero_less_0_iff top_ereal_def ereal_0_gt_inverse)


Input:
lemma invfun_l1:"\<lbrakk>f \<in> A \<rightarrow> B; bij_to f A B; a \<in> A\<rbrakk>
                      \<Longrightarrow> (invfun A B f) (f a) = a"

Output:
apply (simp add:bij_to_def, erule conjE)
apply (rule invfun_l, assumption+) done


Input:
lemma perm_restrict_union:
  assumes "perm_restrict f A permutes A" "perm_restrict f B permutes B" "A \<inter> B = {}"
  shows "perm_restrict f A o perm_restrict f B = perm_restrict f (A \<union> B)"

Output:
using assms
by (auto simp: fun_eq_iff perm_restrict_def permutes_def) (metis Diff_iff Diff_triv)


Input:
lemma (in monoid) associated_sym [sym]:
  assumes "a \<sim> b"
  shows "b \<sim> a"

Output:
using assms
by (iprover intro: associatedI elim: associatedE)


Input:
lemma preserves_iso [simp]:
    assumes "A.iso f"
    shows "B.iso (F f)"

Output:
using assms A.inverse_arrowsE
apply (elim A.isoE A.inverse_arrowsE A.seqE A.ide_compE)
by (metis A.arr_dom_iff_arr B.ide_dom B.inverse_arrows_def B.isoI preserves_arr preserves_comp preserves_dom)


Input: lemma coll_add_cancel: "coll 0 a (a + b) \<Longrightarrow> coll 0 a b"

Output: by (cases a, cases b) (auto simp: det3_def' algebra_simps)


Input:
lemma hyperplane_eq_Ex:
  assumes "a \<noteq> 0" obtains x where "a \<bullet> x = b"

Output: by (rule_tac x = "(b / (a \<bullet> a)) *\<^sub>R a" in that) (simp add: assms)


Input:
lemma invariant_reaches:
  "P b" if "a \<rightarrow>* b" "P a"

Output:
using that
by (induction; blast intro: invariant)


Input:
lemma RECT_gfp_def: "RECT B x =
  (if (trimono B) then (gfp B x) else (top::'a::complete_lattice))"

Output:
unfolding RECT_def
by (auto simp: gfp_eq_flatf_gfp[OF trimonoD_flatf_ge trimonoD_mono])


Input:
lemma comparator_unit_comparator_of [compare_simps]:
  "comparator_unit = comparator_of"

Output:
proof (intro ext) fix a b show "comparator_unit a b = comparator_of a b" unfolding comparator_of_def
by auto
qed


Input:
lemma norm_of_complex_addn [simp]:
  "norm (of_complex x + numeral b :: 'a :: complex_normed_div_algebra) = cmod (x + numeral b)"

Output: by (metis norm_of_complex of_complex_add of_complex_numeral)


Input: lemma integral_None [simp]: "content (cbox a b) = 0 \<Longrightarrow> integral (cbox a b) f = 0"

Output: by (metis has_integral_None integral_unique)


Input:
lemma(in UP_cring) taylor_deg_1_eval':
  assumes "f \<in> carrier P"
  assumes "a \<in> carrier R"
  assumes "b \<in> carrier R"
  assumes "c = to_fun (shift (2::nat) (T\<^bsub>a\<^esub> f)) b"
  assumes "fa = to_fun f a"
  assumes "f'a = deriv f a"
  shows "to_fun f (a \<oplus> b) = fa \<oplus> (f'a \<otimes> b) \<oplus> (c \<otimes> b[^](2::nat))"

Output:
using R.add.m_comm taylor_deg_1_eval assms(1) assms(2) assms(3) assms(4) assms(5) assms(6)
by auto


Input:
lemma (in proper_design) resolution_blocks: "distinct_mset \<B> \<Longrightarrow> disjoint (set_mset \<B>) \<Longrightarrow>
    \<Union>(set_mset \<B>) = \<V> \<Longrightarrow> resolution {#\<B>#}"

Output:
unfolding resolution_def resolution_class_def partition_on_mset_def partition_on_def
using design_blocks_nempty blocks_nempty
by auto


Input:
lemma wd_DC:
  "\<lbrakk> well_def a; well_def b \<rbrakk> \<Longrightarrow> well_def (a \<Sqinter> b)"

Output: by(blast intro:healthy_wp_DC nearly_healthy_wlp_DC wp_under_wlp_DC sdp_DC sublinear_wp_DC cts_wp_DC)


Input:
lemma dw_closedI [intro]:
  assumes "\<And>a b. a \<in> A \<Longrightarrow> a \<rightarrow> b \<Longrightarrow> b \<in> A"
  shows "dw_closed A"

Output:
unfolding dw_closed_def
using assms
by auto


Input: lemma sorted_spvec_cons3: "sorted_spvec(a#b#t) \<Longrightarrow> fst a < fst b"

Output: apply (auto simp add: sorted_spvec.simps) done


Input:
lemma dvd_div_ge_1:
  fixes a b :: nat
  assumes "a \<ge> 1" "b dvd a"
  shows "a div b \<ge> 1"

Output:
proof - from \<open>b dvd a\<close> obtain c where "a = b * c" .. with \<open>a \<ge> 1\<close> show ?thesis
by simp
qed


Input:
lemma ucast_down_minus:
    "is_down (ucast:: 'a word \<Rightarrow> 'b word) \<Longrightarrow>  ucast ((a :: 'a::len word) - b) = (ucast a - ucast b :: 'b::len word)"

Output:
apply (rule ucast_distrib [where L="(-)"], (clarsimp simp: uint_word_ariths)+)
apply (metis mod_diff_left_eq mod_diff_right_eq)
apply simp done


Input:
lemma MkArr_in_hom:
    assumes "A \<in> Obj" and "B \<in> Obj" and "f \<in> Hom A B"
    shows "in_hom (MkArr A B f) (MkIde A) (MkIde B)"

Output:
using assms arr_char ide_MkIde
by (simp add: in_codomains_char in_domains_char in_hom_def)


Input:
lemma smaps_over_un:
  assumes "m1 \<in> smaps_over A B" and "m2 \<in> smaps_over A B"
  shows "m1 \<union>. m2 \<in> smaps_over A B"

Output:
using assms unfolding smaps_over_def
by (auto simp add:smap_union_def)


Input:
lemma interval_less_to_le_low [forward]:
  "(a::('a::linorder idx_interval)) < b \<Longrightarrow> low (int a) \<le> low (int b)"

Output: by (metis eq_iff iint_less int_less less_imp_le)


Input:
lemma vunion_vsingleton_iff:
  "A \<union>\<^sub>\<circ> B = set {x} \<longleftrightarrow>
    A = 0 \<and> B = set {x} \<or> A = set {x} \<and> B = 0 \<or> A = set {x} \<and> B = set {x}"

Output: by ( metis vsubset_vsingletonD inf_sup_ord(4) sup.idem sup_V_0_right sup_commute )


Input:
lemma get_const_distr:
  "a \<noteq> \<infinity> \<Longrightarrow> b \<noteq> \<infinity> \<Longrightarrow> get_const (a + b) = get_const a + get_const b"

Output: by (cases a) (cases b, auto simp: mult)+


Input:
lemma ucast_less_shiftl_helper':
  "\<lbrakk> LENGTH('b) + (a::nat) < LENGTH('a); 2 ^ (LENGTH('b) + a) \<le> n\<rbrakk>
   \<Longrightarrow> (ucast (x :: 'b::len word) << a) < (n :: 'a::len word)"

Output:
apply (erule order_less_le_trans[rotated])
using ucast_less[where x=x and 'a='a]
apply (simp only: shiftl_t2n field_simps)
apply (rule word_less_power_trans2; simp) done


Input:
lemma supset_imp_s_mul_ext:
  assumes "A \<supset># B"
  shows "(A, B) \<in> s_mul_ext NS S"

Output:
using assms subset_mset.add_diff_inverse[of B A]
by (auto intro!: s_mul_extI[of A B "A - B" B B "{#}"] multpw_refl' refl_imp_locally_refl simp: Diff_eq_empty_iff_mset subset_mset.order.strict_iff_order)


Input:
lemma sym_simps [simp]:
    assumes "ide a" and "ide b"
    shows "arr \<s>[a, b]" and "dom \<s>[a, b] = a \<otimes> b" and "cod \<s>[a, b] = b \<otimes> a"

Output:
using assms sym_in_hom
by auto


Input:
lemma less_min_eq2:
  "(a :: 'a :: order) > b \<Longrightarrow> min a b = b"

Output: by(auto simp add: min_def order_less_imp_le)


Input: lemma degeneralize_nodes_fst[simp]: "fst ` b.nodes (degeneralize A) = a.nodes A"

Output:
unfolding a.nodes_alt_def b.nodes_alt_def
by simp


Input:
lemma add_scale_img:
  assumes "a < b" shows "(\<lambda>x::real. a + (b - a) * x) ` {0 .. 1} = {a .. b}"

Output:
using assms
apply (auto simp: algebra_simps affine_ineq image_iff)
using less_eq_real_def
apply force
apply (rule_tac x="(x-a)/(b-a)" in bexI)
apply (auto simp: field_simps) done


Input:
lemma multiplicity_gauss_int_of_nat:
  "multiplicity (of_nat a) (of_nat b :: gauss_int) = multiplicity a b"

Output: unfolding multiplicity_def of_nat_power [symmetric] of_nat_dvd_of_nat_gauss_int_iff ..


Input:
lemma swap_set_in_eq:
  assumes a: "a \<in> S" "b \<notin> S" "sort_of a = sort_of b"
  shows "(a \<rightleftharpoons> b) \<bullet> S = (S - {a}) \<union> {b}"

Output:
unfolding permute_set_def
using a
by (auto simp: swap_atom)


Input:
lemma bounded_convex_hull:
  fixes s :: "'a::real_normed_vector set"
  assumes "bounded s"
  shows "bounded (convex hull s)"

Output:
proof - from assms obtain B where B: "\<forall>x\<in>s. norm x \<le> B" unfolding bounded_iff
by auto show ?thesis
by (simp add: bounded_subset[OF bounded_cball, of _ 0 B] B subsetI subset_hull)
qed


Input:
lemma (in finite_measure) finite_measure_mono:
  assumes "A \<subseteq> B" "B \<in> sets M" shows "measure M A \<le> measure M B"

Output:
using emeasure_mono[OF assms] emeasure_real[of A] emeasure_real[of B]
by (auto simp: measure_def)


Input:
lemma mult_carrier_mat[simp]:
  "A \<in> carrier_mat nr n \<Longrightarrow> B \<in> carrier_mat n nc \<Longrightarrow> A * B \<in> carrier_mat nr nc"

Output:
unfolding carrier_mat_def
by auto


Input:
lemma lfp_gfp_compare:
  \<comment> \<open>Least and greatest fixed point are either equal, or bot and top\<close>
  assumes MLE: "flatf_mono_le B" and MGE: "flatf_mono_ge B"
  shows "flatf_lfp B x = flatf_gfp B x
    \<or> (flatf_lfp B x = bot \<and> flatf_gfp B x = top)"

Output: using fp_compare[OF MLE MGE] .


Input:
lemma (in order_topology) eventually_at_leftI:
  assumes "\<And>x. x \<in> {a<..<b} \<Longrightarrow> P x" "a < b"
  shows   "eventually P (at_left b)"

Output:
using assms unfolding eventually_at_topological
by (intro exI[of _ "{a<..}"]) auto


Input:
lemma vsingleton_Un_iff:
  "set {x} = A \<union>\<^sub>\<circ> B \<longleftrightarrow>
    A = 0 \<and> B = set {x} \<or> A = set {x} \<and> B = 0 \<or> A = set {x} \<and> B = set {x}"

Output: by (metis vunion_vsingleton_iff sup_V_0_left sup_V_0_right sup_idem)


Input:
lemma subst_b_lookup:
  assumes "Some (b, c) = lookup \<Gamma> x"
  shows " Some (b[bv::=b']\<^sub>b\<^sub>b, c[bv::=b']\<^sub>c\<^sub>b) = lookup \<Gamma>[bv::=b']\<^sub>\<Gamma>\<^sub>b x"

Output:
using assms
by(induct \<Gamma> rule: \<Gamma>_induct, auto)


Input:
lemma semantics_in_vertices:
  assumes "graph A" "(a,b) \<in> :A:\<lbrakk>e\<rbrakk>"
  shows "a \<in> vertices A" "b \<in> vertices A"

Output:
using assms
by(induct e arbitrary:a b,auto simp:getRel_def)


Input:
lemma refl_on_restrictPI:
  "refl_onP A r \<Longrightarrow> refl_onP (A \<inter> B) (r |` B)"

Output: by(rule refl_onPI)(blast dest: refl_onPD1 refl_onPD2 refl_onPD)+


Input:
lemma map_default_delete [simp]:
  "map_default b (f(a := None)) = (map_default b f)(a := b)"

Output: by(simp add: map_default_def fun_eq_iff)


Input:
lemma mat_gt_trans: assumes sd: "sd \<le> n" and AB: "mat_gt gt sd A B" and BC: "mat_gt gt sd B C"
  and A: "A \<in> carrier_mat n n" and B: "B \<in> carrier_mat n n"
shows "mat_gt gt sd A C"

Output: using mat_ge_gt_trans[OF sd mat_gt_imp_mat_ge[OF AB] BC A B] .


Input:
lemma resOutputLeft:
  fixes x   :: name
  and   a   :: name
  and   b   :: name
  and   P   :: pi
  and   Rel :: "(pi \<times> pi) set"

  assumes xineqa: "x \<noteq> a"
  and     xineqb: "x \<noteq> b"
  and     Id: "Id \<subseteq> Rel"

  shows "<\<nu>x>a{b}.P \<leadsto>[Rel] a{b}.(<\<nu>x>P)"

Output:
using assms
by(fastforce simp add: simulation_def elim: outputCases intro: Output ResF)


Input: lemma mset_le_incr_right2: "a\<subseteq>#(b::'a multiset) \<Longrightarrow> a\<subseteq>#c+b"

Output:
using mset_le_incr_right1
by (auto simp add: union_commute)


Input:
lemma diff_add_cancel_ennreal:
  fixes a b :: ennreal shows "a \<le> b \<Longrightarrow> b - a + a = b"

Output:
unfolding infinity_ennreal_def
by transfer (metis (no_types) add.commute ereal_diff_positive ereal_ineq_diff_add max_def not_MInfty_nonneg)


Input:
lemma homeomorphic_spheres_gen:
    fixes a :: "'a::euclidean_space" and b :: "'b::euclidean_space"
  assumes "0 < r" "0 < s" "DIM('a::euclidean_space) = DIM('b::euclidean_space)"
  shows "(sphere a r homeomorphic sphere b s)"

Output:
using assms homeomorphic_trans [OF homeomorphic_spheres homeomorphic_spheres']
by auto


Input: lemma value_gt_False_Some: "value_gt a b = False \<Longrightarrow> (\<exists>x. a = Some x) \<and> (\<exists>y. b = Some y)"

Output: by (cases a; cases b, auto simp: value_gt_def)


Input:
lemma possible_steps_select_wrong_arity: "a = STR ''select'' \<Longrightarrow>
       length b \<noteq> 1 \<Longrightarrow>
       possible_steps drinks 0 <> a b = {||}"

Output:
apply (simp add: possible_steps_def ffilter_def fset_both_sides Abs_fset_inverse Set.filter_def drinks_def)
apply safe
by (simp_all add: select_def)


Input:
lemma vec_plus[simp]:
assumes "dims A = dims B"
shows "vec (A+B) = vec_plus (vec A) (vec B)"

Output:
unfolding plus_def plus_base_def vec_plus_def
using assms
by (auto; metis (no_types, lifting) length_map length_tensor_vec_from_lookup map_fst_zip tensor_lookup tensor_from_lookup_def vec_tensor)


Input:
lemma append_cols_carrier[simp,intro]:
  "A \<in> carrier_mat n a \<Longrightarrow> B \<in> carrier_mat n b \<Longrightarrow> (A @\<^sub>c B) \<in> carrier_mat n (a+b)"

Output:
unfolding append_cols_def
by auto


Input:
lemma inverse_less_imp_less_neg:
  "inverse a < inverse b \<Longrightarrow> b < 0 \<Longrightarrow> b < a"

Output:
using local.dual_order.strict_iff_order local.inverse_le_imp_le_neg
by blast


Input:
lemma np_specD3:
  assumes "np_spec np" and "a \<in> set hs" and "b \<in> set hs" and "a \<noteq> b"
  shows "(a, b) \<in>\<^sub>p snd ` set (np gs bs hs data)"

Output:
using assms(1)[unfolded np_spec_def, rule_format, of gs bs hs data] assms(2,3,4)
by blast


Input:
lemma residual_obtain_orig_block:
  assumes "b \<in># \<B>\<^sup>R"
  obtains bl2 where "b = bl2 - bl" and "bl2 \<in># remove1_mset bl \<B>"

Output:
using assms residual_blocks_def
by auto


Input:
lemma Int_stableI:
  "(\<And>a b. a \<in> A \<Longrightarrow> b \<in> A \<Longrightarrow> a \<inter> b \<in> A) \<Longrightarrow> Int_stable A"

Output:
unfolding Int_stable_def
by auto


Input: lemma antisym_Elem: "Elem a b \<Longrightarrow> Not (Elem b a)"

Output:
apply (insert notsym_Elem[of a b])
apply auto done


Input:
lemma equivalence_data_simps\<^sub>B [simp]:
    assumes "B.obj a"
    shows "B.ide (d a)" and "B.ide (e a)" and "B.iso (\<eta> a)" and "B.iso (\<epsilon> a)"
    and "src\<^sub>B (e a) = a" and "trg\<^sub>B (e a) = P\<^sub>0 a" and "src\<^sub>B (d a) = P\<^sub>0 a" and "trg\<^sub>B (d a) = a"
    and "B.dom (e a) = e a" and "B.cod (e a) = e a"
    and "B.dom (d a) = d a" and "B.cod (d a) = d a"
    and "src\<^sub>B (\<eta> a) = a" and "trg\<^sub>B (\<eta> a) = a" and "src\<^sub>B (\<epsilon> a) = P\<^sub>0 a" and "trg\<^sub>B (\<epsilon> a) = P\<^sub>0 a"
    and "B.dom (\<eta> a) = a" and "B.cod (\<eta> a) = d a \<star>\<^sub>B e a"
    and "B.dom (\<epsilon> a) = e a \<star>\<^sub>B d a" and "B.cod (\<epsilon> a) = P\<^sub>0 a"

Output:
using assms chosen_adjoint_equivalence equivalence_data_in_hom\<^sub>B B.in_hhom_def
apply auto
by (meson B.in_homE)+


Input:
lemma (in cf_sspan) cf_sspan_\<gg>'[cat_ss_cs_intros]:
  assumes "a = \<oo>" and "b = \<aa>"
  shows "\<gg> : a \<mapsto>\<^bsub>\<CC>\<^esub> b"

Output:
unfolding assms
by (rule cf_sspan_\<gg>)


Input: lemma ends_in_segment [iff]: "a \<in> closed_segment a b" "b \<in> closed_segment a b"

Output:
unfolding segment_convex_hull
by (auto intro!: hull_subset[unfolded subset_eq, rule_format])


Input: lemma tagged_division_of_self_real: "x \<in> {a .. b::real} \<Longrightarrow> {(x,{a .. b})} tagged_division_of {a .. b}"

Output:
unfolding box_real[symmetric]
by (rule tagged_division_of_self)


Input: lemma "Fr_2 \<F> \<Longrightarrow> \<forall>A B. Br(A) \<and> Br(B) \<longrightarrow> DM1\<^sup>A\<^sup>B \<^bold>\<not>\<^sup>C"

Output:
using CF2 EXP_def pF2 pF3 unfolding conn
by metis


Input: lemma prio_selects_one: "a+b = a \<or> a+b=(b::('e,'a::linorder) Prio)"

Output:
apply (simp add: plus_def)
apply (cases "(a,b)" rule: p_min.cases)
apply simp_all done


Input:
lemma product_reachable_snd[simp]:
      assumes "alphabet\<^sub>1 A \<supseteq> alphabet\<^sub>2 B"
      shows "snd ` c.reachable (product A B) (p, q) = b.reachable B q"

Output:
using assms unfolding a.reachable_alt_def a.path_alt_def unfolding b.reachable_alt_def b.path_alt_def unfolding c.reachable_alt_def c.path_alt_def
by auto force


Input: lemma coprime_of_int_gauss_int: "coprime (of_int a :: gauss_int) (of_int b) = coprime a b"

Output:
unfolding coprime_iff_gcd_eq_1 gcd_of_int_gauss_int
by auto


Input: lemma simp_el_hull:  assumes "b \<in>B G" shows "b \<in>B \<langle>G\<rangle>"

Output:
using simp_elI[of b "\<langle>G\<rangle>"] unfolding self_gen
using assms gen_in simp_el_indecomp[OF \<open>b \<in>B G\<close>]
by auto


Input:
lemma (in module) lincomb_cong:
  assumes h2: "A=B" and h3: "A \<subseteq> carrier M"
    and h4: "\<And>v. v\<in>A \<Longrightarrow> a v = b v" and h5: "b\<in> B\<rightarrow>carrier R"
  shows "lincomb a A = lincomb b B"

Output:
using assms
by (simp cong: finsum_cong2 add: lincomb_def summands_valid ring_subset_carrier)


Input:
lemma REP_CLS:
     assumes "B.is_left_adjoint f"
     shows "REP \<lbrakk>\<lbrakk>f\<rbrakk>\<rbrakk> \<cong>\<^sub>B f"

Output: by (metis (mono_tags, lifting) CLS_in_hom Map.simps(1) in_homE REP_in_Map assms B.iso_class_def B.isomorphic_symmetric mem_Collect_eq)


Input:
lemma list_appendI:
  "\<lbrakk>a \<in> list x A; b \<in> list y A\<rbrakk> \<Longrightarrow> a @ b \<in> list (x+y) A"

Output:
apply (unfold list_def)
apply (simp (no_asm))
apply blast done


Input:
lemma continuous_on_topological:
  "continuous_on s f \<longleftrightarrow>
    (\<forall>x\<in>s. \<forall>B. open B \<longrightarrow> f x \<in> B \<longrightarrow> (\<exists>A. open A \<and> x \<in> A \<and> (\<forall>y\<in>s. y \<in> A \<longrightarrow> f y \<in> B)))"

Output:
unfolding continuous_on_def tendsto_def eventually_at_topological
by metis


Input:
lemma product_simps[simp]:
  "succ (product A B) a (p\<^sub>1, p\<^sub>2) = succ A a p\<^sub>1 \<times> succ B a p\<^sub>2"
  "inputs (product A B) = inputs A \<union> inputs B"
  "outputs (product A B) = outputs A \<union> outputs B"
  "initial (product A B) = (initial A, initial B)"

Output:
unfolding product_def
by simp+


Input:
lemma sigma_sets_UNION:
  "countable B \<Longrightarrow> (\<And>b. b \<in> B \<Longrightarrow> b \<in> sigma_sets X A) \<Longrightarrow> \<Union> B \<in> sigma_sets X A"

Output:
using from_nat_into [of B] range_from_nat_into [of B] sigma_sets.Union [of "from_nat_into B" X A]
by (cases "B = {}") (simp_all add: sigma_sets.Empty cong del: SUP_cong)


Input:
lemma preprm_unit_commutes:
  shows "preprm_unit a b =p preprm_unit b a"

Output:
unfolding preprm_ext_def preprm_unit_def
by simp


Input:
lemma int_not_emptyD:
  "A \<inter> B \<noteq> {} \<Longrightarrow> \<exists>x. x \<in> A \<and> x \<in> B"

Output: by (erule contrapos_np, clarsimp simp: disjoint_iff_not_equal)


Input:
lemma cong_cop_per2_1:
  assumes "A \<noteq> B" and
    "Per A B X" and
    "Per A B Y" and
    "Cong B X B Y" and
    "Coplanar A B X Y"
  shows "X = Y \<or> B Midpoint X Y"

Output: by (meson Per_cases assms(1) assms(2) assms(3) assms(4) assms(5) cop_per2__col coplanar_perm_3 l7_20_bis not_col_permutation_5)


Input:
lemma reachable_finite_sim:
      assumes "finite (b.E\<^sup>* `` b.V0)"
      assumes "\<And>b. b \<in> b.E\<^sup>* `` b.V0 \<Longrightarrow> finite (R\<inverse> `` {b})"
      shows "finite (a.E\<^sup>* `` a.V0)"

Output:
apply (rule finite_subset[OF reachable_sim])
apply (rule finite_ImageI)
apply fact+ done


Input:
lemma subset_finite_imp_set_less_eq_aux:
  "\<lbrakk> A \<subseteq> B; finite B \<rbrakk> \<Longrightarrow> A \<sqsubseteq>' B"

Output: by(cases "A = B")(auto simp add: set_less_eq_aux_def finite_complement_partition intro: psubset_finite_imp_set_less_aux)


Input:
lemma interval_lebesgue_integral_gt_eq:
  fixes a b f
  assumes "a > b"
  shows "interval_lebesgue_integral M a b f = -(LINT x : einterval b a | M. f x)"

Output:
using assms
by (auto simp: interval_lebesgue_integral_def less_imp_le einterval_def)


Input: lemma vec_to_iarray_plus[code_unfold]: "vec_to_iarray (a + b) =  (vec_to_iarray a) + (vec_to_iarray b)"

Output:
unfolding vec_to_iarray_def unfolding plus_iarray_def Let_def
by auto


Input:
lemma ennreal_mult_less_top:
  fixes a b :: ennreal
  shows "a * b < top \<longleftrightarrow> (a = 0 \<or> b = 0 \<or> (a < top \<and> b < top))"

Output: by transfer (auto simp add: top_ereal_def)


Input:
lemma mid__lt:
  assumes "A \<noteq> B" and
    "M Midpoint A B"
  shows "A M Lt A B"

Output:
using assms(1) assms(2) bet__lt1213 midpoint_bet midpoint_distinct_1
by blast


Input:
lemma integral_component_lbound:
  fixes f :: "'a::euclidean_space \<Rightarrow> 'b::euclidean_space"
  assumes "f integrable_on cbox a b"
    and "\<forall>x\<in>cbox a b. B \<le> f(x)\<bullet>k"
    and "k \<in> Basis"
  shows "B * content (cbox a b) \<le> (integral(cbox a b) f)\<bullet>k"

Output:
using assms has_integral_component_lbound
by blast


Input:
lemma mkArr_restrict_eq':
    assumes "arr (mkArr A B (restrict F A))"
    shows "mkArr A B (restrict F A) = mkArr A B F"

Output:
using assms
by (intro mkArr_eqI', auto)


Input:
lemma to_nat_on_inj[simp]:
  "countable A \<Longrightarrow> a \<in> A \<Longrightarrow> b \<in> A \<Longrightarrow> to_nat_on A a = to_nat_on A b \<longleftrightarrow> a = b"

Output:
using inj_on_to_nat_on[of A]
by (auto dest: inj_onD)


Input:
lemma is_map_image:
  assumes "is_map M"
  shows "is_map ((\<lambda>(a, b). (a, f a b)) ` M)"

Output:
using assms unfolding is_map_def
by auto


Input:
lemma closed_open_segment_iff [simp]:
    fixes a :: "'a::euclidean_space"  shows "closed(open_segment a b) \<longleftrightarrow> a = b"

Output: by (metis open_segment_def DiffE closure_eq closure_open_segment ends_in_segment(1) insert_iff segment_image_interval(2))


Input:
lemma has_integral_open_interval:
  fixes f :: "'a :: euclidean_space \<Rightarrow> 'b :: banach"
  shows "(f has_integral y) (box a b) \<longleftrightarrow> (f has_integral y) (cbox a b)"

Output:
unfolding interior_cbox [symmetric]
by (metis frontier_cbox has_integral_interior negligible_frontier_interval)


Input: lemma Sigma_fm_Iff: "\<lbrakk>{} \<turnstile> B IFF A; supp A \<subseteq> supp B; Sigma_fm A\<rbrakk> \<Longrightarrow> Sigma_fm B"

Output: by (metis Sigma_fm_def Iff_trans order_trans)


Input: lemma dbm_not_lt_eq: "\<not> a \<prec> b \<Longrightarrow> \<not> b \<prec> a \<Longrightarrow> a = b"

Output:
apply (cases a)
apply (cases b, fastforce+)+ done


Input:
lemma computation_downpos:"rat_poly_times A (A - rat_poly_times (rat_poly_times B B) B) =
    rat_poly_inv (rat_poly_times B (B - rat_poly_times (rat_poly_times A A) A))"

Output:
using computation_downpos_prelim
by (metis rat_poly.comm)


Input:
lemma comm_add_vecset:
  assumes "(A :: 'a :: ab_semigroup_add vec set) \<subseteq> carrier_vec n"
    and "B \<subseteq> carrier_vec n"
  shows "A + B = B + A"

Output:
unfolding set_plus_def
using comm_add_vec assms
by blast


Input:
lemma drinks2_1_invalid:
  "\<not>(a = (STR ''coin'') \<and> length b = 1) \<Longrightarrow>
      \<not>(a = (STR ''vend'') \<and> b = []) \<Longrightarrow>
    possible_steps drinks2 1 r a b = {||}"

Output:
apply (simp add: possible_steps_empty drinks2_def)
apply safe
by (simp_all add: transitions can_take_transition_def can_take_def value_gt_def)


Input:
theorem vcgaIsMaximal:
  assumes "distinct \<Omega>" "set \<Omega> \<noteq> {}" "finite N" "\<forall> X. b (seller, X) = 0"
  shows "sum b (vcga' N \<Omega> b r) = Max{sum b a| a. a \<in> soldAllocations N (set \<Omega>)}"

Output:
using assms vcgaIsMaximalAux2
by blast


Input: lemma set_of_hom: "\<forall>x \<in> A. f x \<in> B \<Longrightarrow> restrict f A \<in> A \<rightarrow> B"

Output: apply (simp add:Pi_def restrict_def) done


Input:
lemma cancel_semigroup_pair_ow_transfer[transfer_rule]:
  assumes [transfer_rule]:
    "bi_unique A" "right_total A" "bi_unique B" "right_total B"
  shows
    "(
      rel_set A ===> (A ===> A ===> A) ===>
      rel_set B ===> (B ===> B ===> B) ===>
      (=)
    ) cancel_semigroup_pair_ow cancel_semigroup_pair_ow"

Output: by (ow_locale_transfer locale_defs: cancel_semigroup_pair_ow_def)


Input:
lemma tensor_preserves_ide [simp]:
    assumes "ide a" and "ide b"
    shows "ide (a \<otimes> b)"

Output:
using assms T.preserves_ide CC.ide_char
by simp


Input:
lemma INF_nat_binary:
  "inf A (INF x\<in>Collect ((<) (0::nat)). B) = (inf A B::'a::countable_complete_lattice)"

Output:
apply (subst image_constant)
apply auto done


Input:
lemma scaleC_le_0_iff:
  "a *\<^sub>C b \<le> 0 \<longleftrightarrow> 0 < a \<and> b \<le> 0 \<or> a < 0 \<and> 0 \<le> b \<or> a = 0"
  if "a \<in> \<real>" (* Not present in Real_Vector_Spaces *)
  for b::"'a::ordered_complex_vector"

Output:
apply (insert zero_le_scaleC_iff [of "-a" b])
using less_complex_def that
by force


Input: lemma join_False_code[code]: "join A False B = {a \<in> A. \<forall>b \<in> B. join1 (a, b) \<noteq> Some a}"

Output:
unfolding join_False_alt join_True_code
by (auto simp: Option.these_def image_iff dest: self_join1)


Input:
lemma gcd_bezout_sum_nat:
  fixes a::nat
  assumes "a * x + b * y = d"
  shows "gcd a b dvd d"

Output:
proof- let ?g = "gcd a b" have dv: "?g dvd a*x" "?g dvd b * y"
by simp_all from dvd_add[OF dv] assms show ?thesis
by auto
qed


Input:
lemma halfspace_eq_empty_gt:
  "{x. a \<bullet> x > b} = {} \<longleftrightarrow> a = 0 \<and> b \<ge> 0"

Output:
using halfspace_eq_empty_lt [of "-a" "-b"]
by simp


Input: lemma upt_eqD: "upt a b = upt a b' \<Longrightarrow> (b = b' \<or> b' \<le> a \<or> b \<le> a)"

Output: by (induction b) (auto dest!: upt_append_sing split: if_splits)


Input:
lemma preorder_dense_order_ow_transfer[transfer_rule]:
  assumes [transfer_rule]: "right_total A" "bi_unique B" "right_total B"
  shows
    "(
      rel_set A ===> (A ===> A ===> (=)) ===> (A ===> A ===> (=)) ===>
      rel_set B ===> (B ===> B ===> (=)) ===> (B ===> B ===> (=)) ===>
      (=)
    ) preorder_dense_order_ow preorder_dense_order_ow"

Output: by (ow_locale_transfer locale_defs: preorder_dense_order_ow_def)


Input:
lemma mod_integer_ge:
  "b \<le> 0 \<Longrightarrow> 0 < a \<Longrightarrow> b \<le> x mod (a+1)" for a b x :: integer

Output: by (metis dual_order.trans less_add_one order.strict_trans unique_euclidean_semiring_numeral_class.pos_mod_sign)


Input: lemma le_imp_erf_real_le: "a \<le> (b::real) \<Longrightarrow> erf a \<le> erf b"

Output: by (cases "a < b") (auto dest: less_imp_erf_real_less)


Input:
lemma
assumes premise_3: "\<^bold>\<forall> y. \<^bold>\<forall> z. ((E y \<and> \<not> E z) \<longrightarrow> ((y \<^bold>= (\<^bold>\<tau> x. \<Phi> x) \<or> z = (\<^bold>\<tau> x. \<Phi> x)) \<longrightarrow> y =  (\<^bold>\<tau> x. \<Phi> x)))" and something_exists: "\<^bold>\<exists> x. E x" and god_is_conceivable: "C g" and C_atomic: "atomic C"
shows "\<not> E (\<^bold>\<tau> x. \<Phi> x) \<longrightarrow> (\<^bold>\<exists> y. C y \<and> G y (\<^bold>\<tau> x. \<Phi> x))"

Output: by (metis (no_types, lifting) C_atomic description_theorem_3 g_def god_is_conceivable premise_3 something_exists)


Input:
lemma thm_relation_negation_4[PLM]:
    "[(\<^bold>\<not>((p::\<o>)\<^sup>-)) \<^bold>\<equiv> p in v]"

Output:
using thm_relation_negation_3[THEN oth_class_taut_5_d[equiv_lr]]
apply -
by PLM_solver


Input: lemma "(\<exists>x. E x) \<^bold>\<and> (\<exists>C D. (\<^bold>\<forall>y. ID(C y) \<^bold>\<and> (C y)\<cdot>y \<cong> y) \<^bold>\<and> (\<^bold>\<forall>x. ID(D x) \<^bold>\<and> x\<cdot>(D x) \<cong> x) \<^bold>\<and> \<^bold>\<not>(D \<^bold>= C))"

Output: nitpick [satisfy] oops \<comment> \<open>Model found\<close>


Input: lemma width_add1:"\<Turnstile>((\<^bold>\<omega> = x) \<^bold>\<smile> (\<^bold>\<omega> = y) \<^bold>\<rightarrow> \<^bold>\<omega> = x+y)"

Output:
using vertical_chop_add1
by fastforce


Input:
lemma TensorDiag_in_Hom:
    assumes "Diag t" and "Diag u"
    shows "t \<^bold>\<lfloor>\<^bold>\<otimes>\<^bold>\<rfloor> u \<in> Hom (Dom t \<^bold>\<lfloor>\<^bold>\<otimes>\<^bold>\<rfloor> Dom u) (Cod t \<^bold>\<lfloor>\<^bold>\<otimes>\<^bold>\<rfloor> Cod u)"

Output:
using assms TensorDiag_preserves_Diag Diag_implies_Arr
by simp


Input: lemma lcp_mismatch': assumes "\<not> u \<bowtie> v" shows "u! \<^bold>|u \<and>\<^sub>p v\<^bold>| \<noteq> v! \<^bold>|u \<and>\<^sub>p v\<^bold>|"

Output:
using incomp_lcp_len[OF assms, unfolded min_less_iff_conj] lcp_mismatch
by blast


Input: lemma two_pers: assumes "w \<le>p u\<^sup>\<omega>" and  "w \<le>p v\<^sup>\<omega>" and "\<^bold>|u\<^bold>|+\<^bold>|v\<^bold>| \<le> \<^bold>|w\<^bold>|" shows "u\<cdot>v = v\<cdot>u"

Output: using two_pers'[OF per_rootD[OF assms(1)] per_rootD[OF assms(2)] assms(3)] .


Input:
lemma iteI[wp_intro]:
  assumes "\<lbrace>P'\<rbrace> x \<lbrace>Q\<rbrace>"
  assumes "\<lbrace>P''\<rbrace> y \<lbrace>Q\<rbrace>"
  shows "\<lbrace>\<^bold>if b \<^bold>then P' \<^bold>else P''\<rbrace> \<^bold>if b \<^bold>then x \<^bold>else y \<lbrace>Q\<rbrace>"

Output:
using assms
by (simp add: valid_def)


Input: lemma CBarcan_I: "Der_1b \<D> \<Longrightarrow> \<forall>P. \<I>(\<^bold>\<forall>x. P x)  \<^bold>\<preceq> (\<^bold>\<forall>x. \<I>(P x))"

Output: by (metis (mono_tags, lifting) MONO_def monI)


Input:
lemma red_simps [simp]:
    assumes "Ide t"
    shows "Src (t\<^bold>\<down>) = Src t" and "Trg (t\<^bold>\<down>) = Trg t"
    and "Dom (t\<^bold>\<down>) = t" and "Cod (t\<^bold>\<down>) = \<^bold>\<lfloor>t\<^bold>\<rfloor>"

Output:
using assms red_in_Hom
by auto


Input: lemma at_neg_neg2:"\<Turnstile>\<^bold>\<not>(\<^bold>@c \<^bold>\<not> \<phi>) \<^bold>\<rightarrow> (\<^bold>@c  \<phi>)"

Output:
using switch_unique switch_def switch_refl
by metis


Input:
lemma rule_sub_lem_1_b[PLM]:
    "[\<^bold>\<box>(\<psi> \<^bold>\<equiv> \<chi>) in v] \<Longrightarrow> [(\<psi> \<^bold>\<rightarrow> \<Theta>) \<^bold>\<equiv> (\<chi> \<^bold>\<rightarrow> \<Theta>) in v]"

Output: by (metis equiv_def contraposition_1 CP "\<^bold>&E"(2) "\<^bold>\<equiv>I" "\<^bold>\<equiv>E"(1) rule_sub_lem_1_a)


Input:
lemma thm_relation_negation_1_1[PLM]:
    "[\<lparr>F\<^sup>-, x\<^sup>P\<rparr> \<^bold>\<equiv> \<^bold>\<not>\<lparr>F, x\<^sup>P\<rparr> in v]"

Output:
unfolding propnot_defs
apply (rule lambda_predicates_2_1[axiom_instance])
by show_proper


Input:
lemma CompDiag_Inv_Can [simp]:
    assumes "Can t" and "Diag t"
    shows "Inv t \<^bold>\<lfloor>\<^bold>\<cdot>\<^bold>\<rfloor> t = Dom t"

Output:
using assms Can_and_Diag_implies_Ide Ide_in_Hom
by simp


Input:
lemma thm_relation_negation_10[PLM]:
    "[((p::\<o>) \<^bold>= q) \<^bold>\<rightarrow> ((p\<^sup>-) \<^bold>= (q\<^sup>-)) in v]"

Output:
using l_identity[where \<alpha>="p" and \<beta>="q" and \<phi>="\<lambda> x . (p\<^sup>-) \<^bold>= (x\<^sup>-)", axiom_instance, deduction] id_eq_prop_prop_7_b
using CP modus_ponens
by blast


Input:
lemma KBasic2_11[PLM]:
    "[\<^bold>\<diamond>\<^bold>\<diamond>\<phi> \<^bold>\<equiv> (\<^bold>\<not>(\<^bold>\<box>\<^bold>\<box>(\<^bold>\<not>\<phi>))) in v]"

Output:
unfolding diamond_def
apply (PLM_subst_method "\<^bold>\<box>(\<^bold>\<not>\<phi>)" "\<^bold>\<not>(\<^bold>\<not>(\<^bold>\<box>(\<^bold>\<not>\<phi>)))")
using oth_class_taut_4_b oth_class_taut_4_a
by auto


Input: lemma AG_fp_2: "\<^bold>A\<^bold>G p \<subseteq> \<^bold>A\<^bold>X \<^bold>A\<^bold>G p"

Output:
proof - note AG_fp also have "p \<inter> \<^bold>A\<^bold>X \<^bold>A\<^bold>G p \<subseteq> \<^bold>A\<^bold>X \<^bold>A\<^bold>G p"
by auto finally show ?thesis .
qed


Input: lemma eq_len_iff_less: assumes eq: "x \<cdot> y = u \<cdot> v" shows "\<^bold>|x\<^bold>| < \<^bold>|u\<^bold>| \<longleftrightarrow> \<^bold>|v\<^bold>| < \<^bold>|y\<^bold>|"

Output:
using lenarg[OF eq] unfolding length_append
by auto


Input: lemma hchop_neg1:"\<Turnstile> \<^bold>\<not> (\<phi> \<^bold>\<frown> \<^bold>\<top>) \<^bold>\<rightarrow> ((\<^bold>\<not> \<phi>) \<^bold>\<frown> \<^bold>\<top>)"

Output:
using horizontal_chop1
by fastforce


Input: lemma "CoP2 \<^bold>\<not>\<^sup>I \<longrightarrow> TNDm \<^bold>\<not>\<^sup>I"

Output:
using XCoP_def2 CoP2_XCoP TNDm_def TNDw_def
by auto


Input:
lemma Diagonalize_COD:
    assumes "arr f"
    shows "\<^bold>\<lfloor>COD f\<^bold>\<rfloor> = Cod \<^bold>\<lfloor>rep f\<^bold>\<rfloor>"

Output:
using assms Diag_Diagonalize
by simp


Input:
lemma E_bipartite_web:
  fixes \<Gamma> (structure) shows
  "\<^bold>E\<^bsub>bipartite_web_of \<Gamma>\<^esub> = (\<lambda>(x, y). (Inl x, Inr y)) ` \<^bold>E \<union> (\<lambda>x. (Inl x, Inr x)) ` (\<^bold>V - A \<Gamma> - B \<Gamma>)"

Output: by(auto elim: edge_bipartite_webE)


Input:
lemma raa_cor_2[PLM]:
    "\<lbrakk>[\<^bold>\<not>\<phi> in v]; [\<^bold>\<not>\<psi> in v] \<Longrightarrow> [\<phi> in v]\<rbrakk> \<Longrightarrow> ([\<^bold>\<not>\<phi> in v] \<Longrightarrow> [\<psi> in v])"

Output:
using reductio_aa_1 vdash_properties_9
by blast


Input:
lemma f1_code1 [code]:
  "f1 b c d    ns     = Code.abort (STR ''4'') (\<lambda>_. ())"
  "f1 b c True \<^bold>[n, m\<^bold>] = Code.abort (STR ''3'') (\<lambda>_. ())"
  "f1 b True d \<^bold>[n\<^bold>]    = Code.abort (STR ''2'') (\<lambda>_. ())"
  "f1 True c d \<^bold>[\<^bold>]     = ()"

Output: by(simp_all add: f1_def)


Input:
lemma ActualBoxE[PLM_elim, PLM_dest]:
      "[\<^bold>\<A>(\<^bold>\<box>\<phi>) in v] \<Longrightarrow> [\<^bold>\<box>\<phi> in v]"

Output: using qml_act_2[axiom_instance, equiv_rl] .


Input:
lemma en_eq_2[PLM]:
    "[\<lbrace>x,F\<rbrace> \<^bold>\<equiv> \<^bold>\<box>\<lbrace>x,F\<rbrace> in v]"

Output:
using encoding[axiom_instance] qml_2[axiom_instance]
by (rule "\<^bold>\<equiv>I")


Input: lemma CoP1_LNC: "CoP1 \<^bold>\<not> \<Longrightarrow> LNC \<^bold>\<not>"

Output:
using CoP1_def ECQm_def LNC_def Cl_fr_def Disj_I ECQm_def unfolding conn
by smt


Input: lemma "[\<Gamma> \<^bold>\<turnstile> \<bullet>a, a \<^bold>\<or> \<^bold>\<not>a]"

Output:
using IB_rel Int_br_def compl_def diff_def dual_def eq_ext' ineg_def join_def
by fastforce


Input: lemma "\<lfloor>\<^bold>\<box>\<^bold>\<exists>\<^sup>E (Q::\<up>\<langle>\<zero>\<rangle>) \<^bold>\<leftrightarrow> ((\<lambda>X. \<^bold>\<box>\<^bold>\<exists>\<^sup>E X) \<^bold>\<down>Q)\<rfloor>"

Output: nitpick oops \<comment> \<open>not equivalent!\<close>


Input:
lemma useful_tautologies_6[PLM]:
    "[(\<phi> \<^bold>\<rightarrow> \<^bold>\<not>\<psi>) \<^bold>\<rightarrow> (\<psi> \<^bold>\<rightarrow> \<^bold>\<not>\<phi>) in v]"

Output: by (metis CP useful_tautologies_4 vdash_properties_10)


Input:
lemma ActualNotE[PLM_elim,PLM_dest]:
      "[\<^bold>\<A>\<^bold>\<not>\<phi> in v] \<Longrightarrow> [\<^bold>\<not>\<^bold>\<A>\<phi> in v]"

Output: using logic_actual_nec_1[axiom_instance, equiv_lr] .


Input:
lemma reductio_aa_4[PLM]:
    "\<lbrakk>[\<phi> \<^bold>\<rightarrow> \<^bold>\<not>\<psi> in v]; [\<phi> \<^bold>\<rightarrow> \<psi> in v]\<rbrakk> \<Longrightarrow> [\<^bold>\<not>\<phi> in v]"

Output:
using reductio_aa_2 vdash_properties_10
by blast


Input:
lemma Diagonalize_red2 [simp]:
    assumes "Ide a" and "Ide b" and "Diag a" and "Diag b"
    shows "\<^bold>\<lfloor>a \<^bold>\<Down> b\<^bold>\<rfloor> = \<^bold>\<lfloor>a \<^bold>\<otimes> b\<^bold>\<rfloor>"

Output:
using assms Can_red2 Ide_Diagonalize_Can Diagonalize_in_Hom [of "a \<^bold>\<Down> b"] red2_in_Hom Ide_in_Hom
by simp


Input: lemma length_add1:"\<Turnstile>((\<^bold>\<l>=x) \<^bold>\<frown> (\<^bold>\<l>= y)) \<^bold>\<rightarrow> (\<^bold>\<l>= x+y)"

Output:
using hchop_def real_int.rchop_def real_int.length_def
by fastforce


Input:
lemma pderivs_lang_subsetI:
  assumes "\<And>s. s \<in> A \<Longrightarrow> pderivs s r \<subseteq> C"
  shows "pderivs_lang A r \<subseteq> C"

Output:
using assms unfolding pderivs_lang_def
by (rule UN_least)


Input:
lemma R_assignr: "R = (\<lambda>s. Q (\<chi> j. ((($) s)(x := e s)) j)) \<Longrightarrow>
  rel_R \<lceil>P\<rceil> \<lceil>R\<rceil>; (x ::= e) \<le> rel_R \<lceil>P\<rceil> \<lceil>Q\<rceil>"

Output:
apply(rule_tac R=R in R_seq_law, simp)
by (rule_tac R_assign_law, simp)


Input:
lemma white_valid_ref[elim!]:
  "white r s \<Longrightarrow> valid_ref r s"

Output:
unfolding white_def
by (simp_all split: obj_at_splits)


Input:
lemma finite_enumerate:
  assumes fS: "finite S"
  shows "\<exists>r::nat\<Rightarrow>nat. strict_mono_on r {..<card S} \<and> (\<forall>n<card S. r n \<in> S)"

Output:
unfolding strict_mono_def
using finite_enumerate_in_set[OF fS] finite_enumerate_mono[of _ _ S] fS
by (metis lessThan_iff strict_mono_on_def)


Input: lemma (in project) lang_pnPlus[simp]: "\<lbrakk>wf n r; wf n s\<rbrakk> \<Longrightarrow> lang n (pnPlus r s) = lang n (Plus r s)"

Output: by (induct r s rule: pnPlus.induct) (auto dest!: lang_subset_lists dest: project subsetD[OF star_subset_lists, unfolded in_lists_conv_set, rotated -1] subsetD[OF conc_subset_lists, unfolded in_lists_conv_set, rotated -1])


Input:
lemma l2_run_ended_trans:
  "run_ended (progress s R) \<Longrightarrow>
   (s, s') \<in> trans l2 \<Longrightarrow>
   run_ended (progress s' R)"

Output:
apply (auto simp add: l2_nostep_defs)
apply (simp add: l2_defs, fast ?)+ done


Input: lemma uncurry0_hfref_post[to_hfref_post]: "hfref (uncurry0 True) R S = hfref (\<lambda>_. True) R S"

Output:
apply (fo_rule arg_cong fun_cong)+
by auto


Input:
lemma(in UP_cring) poly_shift_subring_closed:
  assumes "subring S R"
  assumes "g \<in> carrier (UP (R \<lparr> carrier := S \<rparr>))"
  shows "poly_shift g \<in> carrier (UP (R \<lparr> carrier := S \<rparr>))"

Output:
using UP_cring.poly_shift_closed[of "R \<lparr> carrier := S \<rparr>" g] assms UP_ring_subring[of S]
by simp


Input: lemma \<dd>_mono[dest]: "r \<le> s \<Longrightarrow> \<dd> r a \<le> \<dd> s a"

Output:
unfolding less_eq_language_def
by (metis Plus.simps(2))


Input: lemma lang_derivs: "lang (derivs s r) = Derivs s (lang r)"

Output: by (induct s arbitrary: r) (simp_all add: lang_deriv)


Input:
lemma ring_hom_cringI:
  assumes "cring R"
    and "cring S"
    and "h \<in> ring_hom R S"
  shows "ring_hom_cring R S h"

Output: by (fast intro: ring_hom_cring.intro ring_hom_cring_axioms.intro cring.axioms assms)


Input:
lemma open_fls_def:
  "open (S :: 'a::group_add fls set) = (\<forall>a \<in> S. \<exists>r. r >0 \<and> {y. dist y a < r} \<subseteq> S)"

Output:
unfolding open_dist subset_eq
by simp


Input:
lemma(in UP_cring) poly_lift_hom_X_var'':
  assumes "cring S"
  assumes "\<phi> \<in> ring_hom R S"
  shows "poly_lift_hom R S \<phi> (monom (UP R) \<one>\<^bsub>R\<^esub> n) = (monom (UP S) \<one>\<^bsub>S\<^esub> n)"

Output:
using assms(1) assms(2) poly_lift_hom_monom ring_hom_one
by fastforce


Input: lemma finite_set_rel_transfer_back: "\<lbrakk>(s,s')\<in>\<langle>R\<rangle>set_rel; single_valued (R\<inverse>); finite s'\<rbrakk> \<Longrightarrow> finite s"

Output:
unfolding set_rel_alt
by (blast intro: finite_subset[OF _ finite_Image_sv])


Input:
lemma recognises_single_possible_step:
  assumes "possible_steps e s r l i = {|(s', t)|}"
      and "recognises_execution e s' (evaluate_updates t i r) trace"
    shows "recognises_execution e s r ((l, i)#trace)"

Output:
apply (rule recognises_execution.step)
using assms
by auto


Input:
lemma sig_red_zeroI:
  assumes "(sig_red sing_reg (\<preceq>) F)\<^sup>*\<^sup>* r s" and "rep_list s = 0"
  shows "sig_red_zero sing_reg F r"

Output:
unfolding sig_red_zero_def
using assms
by blast


Input:
lemma rtos_hom3_1:"\<lbrakk>(0::nat) < r; (0::nat) < s; i \<le> (r * s - Suc 0) \<rbrakk> \<Longrightarrow>
  (rtos r s i mod  r) = i div s"

Output:
apply (simp add:rtos_def)
apply (simp add:rfn_tool11 [of "r * s" "i"])
apply (frule rtos_hom0 [of "r" "s" "i"], assumption+)
apply (simp add:mem_of_Nset) done


Input:
lemma regular_subtr:
assumes r: "regular tr" and s: "subtr ns tr' tr"
shows "regular tr'"

Output:
using r reg_subtr[OF _ s] unfolding regular_def
by auto


Input:
lemma oneof_length:
  assumes "oneof xs s = Inr (y, r)"
  shows "length s \<ge> length y + length r \<and> y \<in> set xs"

Output:
proof - from oneof_result [OF assms] obtain w where "s = y @ w @ r \<and> y \<in> set xs" .. thus ?thesis
by auto
qed


Input:
lemma trace_reject:
  "(\<not> recognises_execution e s r ((l, i)#t)) = (possible_steps e s r l i = {||} \<or> (\<forall>(s', T) |\<in>| possible_steps e s r l i. \<not> recognises_execution e s' (evaluate_updates T i r) t))"

Output:
using recognises_prim
by fastforce


Input:
lemma eq_from_eq_frac:
  assumes "local.frac r s = local.frac r' s'"
    and "s \<in> (R \<setminus> I)" and "s' \<in> (R \<setminus> I)" and "r \<in> R" "r' \<in> R"
  obtains h where "h \<in> (R \<setminus> I)" "h \<cdot> (s' \<cdot> r - s \<cdot> r') = \<zero>"

Output:
using local.frac_eq_Ex[of r s r' s'] assms
by blast


Input: lemma equivp_inf: "\<lbrakk>equivp R; equivp S\<rbrakk> \<Longrightarrow> equivp (inf R S)"

Output:
unfolding equivp_def inf_fun_def inf_bool_def
by metis


Input:
lemma Alt_eq_map_rexp_iff:
  "Alt r s = map_rexp f x \<longleftrightarrow> (\<exists>r' s'. x = Alt r' s' \<and> map_rexp f r' = r \<and> map_rexp f s' = s)"
  "map_rexp f x = Alt r s \<longleftrightarrow> (\<exists>r' s'. x = Alt r' s' \<and> map_rexp f r' = r \<and> map_rexp f s' = s)"

Output: by (cases x; auto)+


Input:
lemma ocomplete_no_cast [simp]:
  "((\<sigma>, s), R:*cast(m), (\<sigma>', s')) \<notin> ocnet_sos T"

Output:
proof assume "((\<sigma>, s), R:*cast(m), (\<sigma>', s')) \<in> ocnet_sos T" hence "R:*cast(m) \<noteq> R:*cast(m)"
by (rule ocnet_sos.cases) auto thus False
by simp
qed


Input: theorem Times_assoc[simp]: "Times (Times r s) t = Times r (Times s t)"

Output: by (coinduction arbitrary: r s t rule: language_coinduct_upto_Plus) fastforce


Input:
lemma constant_function_comp_is_constant_seq:
  assumes "a \<in> carrier R"
  assumes "s \<in> closed_seqs R"
  shows "is_constant_seq R ((const a) \<circ> s)"

Output:
apply(rule is_constant_seqI[of _ _ a] )
apply (simp add: assms(1) assms(2) constant_function_comp_is_closed_seq)
using assms(1) assms(2) closed_seqs_memE
by (simp add: closed_seqs_memE constant_functionE)


Input: lemma reduction_language_subset: "R.language \<subseteq> S.language"

Output:
unfolding S.language_def R.language_def
using reduction_words_inf
by blast


Input: lemma conc_fun_chain: "\<Down>R (\<Down>S M) = \<Down>(R O S) M"

Output:
unfolding conc_fun_def
by (auto split: nres.split)


Input: lemma matcher_correctness: "matcher r s \<longleftrightarrow> s \<in> lang r"

Output: by (induct s arbitrary: r) (simp_all add: Noneable_iff lang_deriv matcher_def Deriv_def)


Input:
theorem (in ring_hom_ring) FactRing_iso_set:
  assumes "h ` carrier R = carrier S"
  shows "(\<lambda>X. the_elem (h ` X)) \<in> ring_iso (R Quot (a_kernel R S h)) S"

Output:
using FactRing_iso_set_aux assms
by auto


Input: lemma eta_star_preserves_typ_of: "r \<rightarrow>\<^sub>\<eta>\<^sup>* s \<Longrightarrow> typ_of r = Some T  \<Longrightarrow> typ_of s = Some T"

Output:
using eta_star_preserves_typ_of1 typ_of_def
by simp


Input:
lemma(in UP_cring) poly_lift_hom_comm_taylor_expansion:
  assumes "cring S"
  assumes "\<phi> \<in> ring_hom R S"
  assumes "p \<in> carrier P"
  assumes "a \<in> carrier R"
  shows "poly_lift_hom R S \<phi> (taylor_expansion R a p) = taylor_expansion S (\<phi> a) (poly_lift_hom R S \<phi> p)"

Output:
unfolding taylor_expansion_def
using poly_lift_hom_sub[of S \<phi> p "(X_poly_plus R a)"] poly_lift_hom_X_plus[of S \<phi> a] assms
by (simp add: P_def UP_cring.X_plus_closed UP_cring_axioms)


Input: lemma eq_mrexp3_imp_eq: "\<lbrakk>eq_mrexp3 r s; ok3 r; ok3 s\<rbrakk> \<Longrightarrow> (r = s)"

Output: by (induct rule: eq_mrexp3.induct) auto


Input: lemma mset_ran_eq_single_conv: "mset_ran a r = {#x#} \<longleftrightarrow> (\<exists>i. r={i} \<and> x= a i)"

Output:
apply (cases "finite r")
apply (auto simp: mset_ran_def)
using finite_set_mset_mset_set msed_map_invR
by force


Input: lemma le_list_appendI: "a [\<sqsubseteq>\<^bsub>r\<^esub>] b \<Longrightarrow> c [\<sqsubseteq>\<^bsub>r\<^esub>] d \<Longrightarrow> a@c [\<sqsubseteq>\<^bsub>r\<^esub>] b@d"

Output:
apply (unfold Listn.le_def lesub_def)
apply (rule list_all2_appendI, assumption+) done


Input:
lemma genPrefix_prefix_trans:
  "[| (x,y) \<in> genPrefix r;  y<=z |] ==> (x,z) \<in> genPrefix r"

Output:
apply (unfold prefix_def)
apply (drule genPrefix_trans_O, assumption)
apply simp done


Input:
lemma (in Ring) tnm_bilinear:"\<lbrakk>R module M; R module N; FM\<^bsub>R\<^esub> P M N\<rbrakk> \<Longrightarrow>
        bilinear_map (tnm R P M N) R M N (M \<^bsub>P\<^esub>\<Otimes>\<^bsub>R\<^esub> N)"

Output:
apply (simp add:tnm_def)
apply (simp add:tau_mpj_bilinear) done


Input:
lemma (in TwoRings) i_contract_mono:"\<lbrakk>f \<in> rHom R R'; ideal R' J1; ideal R' J2;
 J1 \<subseteq> J2 \<rbrakk> \<Longrightarrow> i_contract f R R' J1 \<subseteq> i_contract f R R' J2"

Output:
apply (rule subsetI)
apply (simp add:i_contract_def invim_def)
apply (erule conjE)
apply (rule subsetD, assumption+) done


Input: lemma med_progress_dom [simp]: "dom (med_progress r) = dom r"

Output:
apply (auto simp add: domIff med_progress_def)
apply (rename_tac x y, case_tac "r x", auto) done


Input: lemma tfl_cut_apply: "\<forall>f R. (x,a)\<in>R \<longrightarrow> (cut f R a)(x) = f(x)"

Output:
apply clarify
apply (rule cut_apply, assumption) done


Input:
lemma return_sp_rule:
  "<P> return x <\<lambda>r. P * \<up>(r = x)>"

Output:
unfolding hoare_triple_def Let_def
apply (simp add: Abs_assn_inverse)
apply (auto elim!: run_elims intro!: relH_refl intro: models_in_range)
apply (simp add: in_range.simps) done


Input:
lemma le_list_map_OK [simp]:
  "\<And>b. (map OK a [\<sqsubseteq>\<^bsub>Err.le r\<^esub>] map OK b) = (a [\<sqsubseteq>\<^sub>r] b)"

Output:
apply (induct a)
apply simp
apply simp
apply (case_tac b)
apply simp
apply simp done


Input:
lemma strong_low_bisim_mm_R\<^sub>C_of_RelS_\<R>:
  "conc.strong_low_bisim_mm (R\<^sub>C_of (A.\<R> \<Gamma> \<S> P) RelS_Eg1Eg2 \<I>simple)"

Output:
apply(rule R\<^sub>C_of_strong_low_bisim_mm)
apply(rule A.\<R>_bisim)
apply(rule RelS_Eg1Eg2_secure_refinement_\<R>)
apply(simp add: sym_def \<I>simple_def) done


Input:
lemma add_poly_l_spec:
  \<open>(add_poly_l, uncurry (\<lambda>p q. SPEC(\<lambda>r. add_poly_p\<^sup>*\<^sup>* (p, q, {#}) ({#}, {#}, r)))) \<in>
    sorted_poly_rel \<times>\<^sub>r sorted_poly_rel \<rightarrow>\<^sub>f \<langle>sorted_poly_rel\<rangle>nres_rel\<close>

Output:
unfolding add_poly_l_add_poly
apply (intro nres_relI frefI)
apply (drule add_poly_l'_add_poly_p)
apply (auto simp: conc_fun_RES) done


Input: lemma Cons_notle_Nil [iff]: "\<not> x#xs [\<sqsubseteq>\<^bsub>r\<^esub>] []"

Output:
apply (unfold lesub_def Listn.le_def)
apply simp done


Input:
lemma bisim_simple_\<R>\<^sub>3:
  "lc \<R>\<^sup>3\<^bsub>\<Gamma>,\<S>,P\<^esub> lc' \<Longrightarrow> (fst (fst lc)) = (fst (fst lc'))"

Output:
apply(induct rule: \<R>\<^sub>3_aux.induct)
using bisim_simple_\<R>\<^sub>1
apply clarsimp
apply simp done


Input: lemma diamond_confluent: "diamond R ==> confluent R"

Output:
apply (unfold diamond_def)
apply (erule commute_rtrancl) done