Input:
lemma in_orthogonal_complement_imp_orthogonal:
  assumes x: "y \<in> S"
  and "x \<in> orthogonal_complement S"
  shows "orthogonal x y"

Output:
using assms orthogonal_commute unfolding orthogonal_complement_def
by blast


Input:
lemma arg_eqD: assumes "arg (cis x) = arg (cis y)" "-pi < x" "x \<le> pi" "-pi < y" "y \<le> pi"
  shows "x = y"

Output: using assms(1) unfolding arg_unique[OF sgn_cis assms(2-3)] arg_unique[OF sgn_cis assms(4-5)] .


Input: lemma pmf_embed_pmf: "pmf embed_pmf x = f x"

Output:
proof transfer have *[simp]: "\<And>x y. ennreal (f y) * indicator {x} y = ennreal (f x) * indicator {x} y"
by (simp split: split_indicator) fix x show "measure (density (count_space UNIV) (ennreal \<circ> f)) {x} = f x"
by transfer (simp add: measure_def emeasure_density nonneg max_def)
qed


Input: lemma X_Y_AX: "X = Choice AX Y"  "Y = Action ''b'' X"  "AX = Action ''a'' X"

Output:
unfolding X_def Y_def AX_def
by (subst F.code, simp)+


Input:
lemma ordinal_dvd_times_div:
"y dvd x \<Longrightarrow> y * (x div y) = (x::ordinal)"

Output:
apply (cut_tac x=x and y=y in ordinal_div_plus_mod)
apply (simp add: ordinal_dvd_mod) done


Input:
lemma ODNmap_mem:"\<lbrakk>Worder D; x = ordinal_number D; y \<in> ODnums; ODord y x\<rbrakk> \<Longrightarrow>
      ODNmap D y \<in> carrier D \<and>
             (\<forall>Y\<in>y. ord_equiv Y (Iod D (segment D (ODNmap D y))))"

Output:
apply (frule ODnum_segmentTr [of "D" "x" "y"], assumption+)
apply (simp add:ODNmap_def)
apply (rule someI2_ex, assumption+) done


Input:
lemma d_galois:
  "d(x) \<le> d(y) \<longleftrightarrow> x \<le> d(y) * top"

Output: by (metis d_export d_isotone d_mult_left_absorb_sup d_plus_one d_restrict_equals d_top mult_isotone top.extremum)


Input: lemma d_restrict_iff: "(x \<le> y) \<longleftrightarrow> (x \<le> d x \<cdot> y)"

Output: by (metis dom_subid_aux2 dsg1 less_eq_def order_trans subdistl)


Input:
lemma (in comm_group) set_mult_commute:
  assumes "N \<subseteq> carrier G" "x \<in> rcosets N" "y \<in> rcosets N"
  shows "x <#> y = y <#> x"

Output:
using assms unfolding set_mult_def RCOSETS_def
by auto (metis m_comm r_coset_subset_G subsetCE)+


Input: lemma infty_assn_pure_conv: "infty_assn (pure A) = pure (\<langle>A\<rangle>infty_rel)"

Output:
apply (intro ext) subgoal for x y
by (cases x; cases y; simp add: pure_def) done


Input:
lemma div_right_ineq:
 assumes "(x::nat) < y*z"
 shows " (x div y) < z"

Output:
using assms div_left_ineq mult.commute
by (metis)


Input:
lemma add_left:
  "(\<And>x y. le x y \<Longrightarrow> f x \<le> f y) \<Longrightarrow> vnm_utility carrier le (\<lambda>x. f x + u x)"

Output: by (subst add.commute) (rule add_right)


Input:
lemma circ_sup_sub_sup_one:
  "x * x\<^sup>\<circ> * (x \<squnion> y) \<le> x * x\<^sup>\<circ> * (1 \<squnion> y)"

Output: by (metis circ_sup_sub_sup_one_2 mult_assoc mult_right_isotone)


Input:
lemma zero_vector_2:
  "zero_vector x \<longleftrightarrow> (\<forall>y . x * y \<le> x * bot)"

Output: by (metis eq_refl order_trans top_right_mult_increasing zero_vector_def zero_vector_left_zero)


Input:
lemma inf_eq_top_iff [simp]:
  "(x :: 'a :: bounded_lattice_top) \<sqinter> y = \<top> \<longleftrightarrow> x = \<top> \<and> y = \<top>"

Output:
quickcheck[expect = no_counterexample]
by (simp add: eq_iff)


Input:
lemma rel_gpv''_mono' [mono]:
  assumes "\<And>x y. A x y \<longrightarrow> A' x y"
    and "\<And>x y. C x y \<longrightarrow> C' x y"
    and "\<And>x y. R' x y \<longrightarrow> R x y"
  shows "rel_gpv'' A C R gpv gpv' \<longrightarrow> rel_gpv'' A' C' R' gpv gpv'"

Output:
using rel_gpv''_mono[of A A' C C' R' R] assms
by(blast)


Input:
lemma homeomorphic_map_swap:
   "homeomorphic_map (prod_topology X Y) (prod_topology Y X) (\<lambda>(x,y). (y,x))"

Output:
using homeomorphic_map_maps homeomorphic_maps_swap
by metis


Input: lemma bounded_linear_mult_right: "bounded_linear (\<lambda>y::'a::real_normed_algebra. x * y)"

Output:
using bounded_bilinear_mult
by (rule bounded_bilinear.bounded_linear_right)


Input: lemma retract_bc: "R\<^sup>*\<^sup>* (\<pi>_Fbcb x) y \<Longrightarrow> \<exists>z. Ebc x z \<and> y = \<pi>_Fbcb z"

Output: by(induction rule: rtranclp_induct)(blast dest: retract1_bc intro: equivp_transp[OF equivp_bc] equivp_reflp[OF equivp_bc])+


Input: lemma length_int_mono_lt0: "[| x \<le> y ; y \<le> 0 |] ==> length_int y \<le> length_int x"

Output: by (cases "y = 0") (simp_all add: length_int_lt0)


Input:
lemma swapEnv_involutive2[simp]:
assumes good: "goodEnv rho"
shows "((rho &[x \<and> y]_zs) &[y \<and> x]_zs) = rho"

Output:
using assms
by(simp add: swapEnv_sym)


Input:
lemma rel_mset_Zero_iff[simp]:
  shows "rel_mset rel {#} Y \<longleftrightarrow> Y = {#}" and "rel_mset rel X {#} \<longleftrightarrow> X = {#}"

Output:
using rel_mset_Zero rel_mset_size
by (fastforce, fastforce)


Input:
lemma from_bool_eqI:
  "from_bool x = from_bool y \<Longrightarrow> x = y"

Output:
unfolding from_bool_def
by (auto split: bool.splits)


Input:
lemma wfp_on_induct [consumes 2, case_names less, induct pred: wfp_on]:
  assumes "wfp_on P A" and "x \<in> A"
    and "\<And>y. \<lbrakk> y \<in> A; \<And>x. \<lbrakk> x \<in> A; P x y \<rbrakk> \<Longrightarrow> Q x \<rbrakk> \<Longrightarrow> Q y"
  shows "Q x"

Output:
using assms and inductive_on_induct [of P A x] unfolding wfp_on_iff_inductive_on
by blast


Input: lemma join_le_iff[simp]: "x \<squnion> y \<sqsubseteq> z \<longleftrightarrow> x \<sqsubseteq> z \<and> y \<sqsubseteq> z"

Output: by (metis join_ge1 join_ge2 join_least le_trans)


Input:
lemma swap_delete_add_edge:
  assumes "(a, b, c) \<noteq> (x, y, z)"
  shows "delete_edge a b c (add_edge x y z H) = add_edge x y z (delete_edge a b c H)"

Output:
using assms unfolding delete_edge_def add_edge_def
by auto


Input: lemma minus_octo_of_real_eq_octo_of_real_iff [simp]: "-octo_of_real x = octo_of_real y \<longleftrightarrow> -x = y"

Output:
using octo_of_real_eq_iff[of "-x" y]
by (simp only: octo_of_real_minus)


Input: lemma add_to_nat_def: "x + y = from_nat (to_nat x + to_nat y)"

Output:
unfolding from_nat_def to_nat_def o_def
using Rep_ge_0[of x]
using Rep_ge_0[of y]
using Rep_less_n[of x] Rep_less_n[of y] unfolding Abs'_def unfolding add_def[of x y]
by auto


Input:
lemma add_BIT_simps [simp]:
  "x BIT False + y BIT False = (x + y) BIT False"
  "x BIT False + y BIT True = (x + y) BIT True"
  "x BIT True + y BIT False = (x + y) BIT True"
  "x BIT True + y BIT True = (x + y + 1) BIT False"

Output: by (simp_all add: Bit_B0_2t Bit_B1_2t)


Input: lemma narrow2_acom: "y \<sqsubseteq> x \<Longrightarrow> x \<triangle>\<^sub>c y \<sqsubseteq> x"

Output: by(induct y x rule: le_acom.induct) (simp_all add: narrow2)


Input: lemma mklr_leq [iff]: "\<lbrakk> x \<in> admS; y \<in> admS \<rbrakk> \<Longrightarrow> (mklr x \<le> mklr y) \<longleftrightarrow> (x \<le> y)"

Output:
unfolding less_eq_admS_def
by simp


Input:
lemma r_nf_t_1:
  assumes "eval r_result [pdec1 y, pdec12 y, pdec22 y] \<down>= 0 \<or> pdec2 y \<noteq> prod_encode (i, x)"
  shows "eval r_nf_t [y, i, x] \<down>= 1"

Output:
unfolding r_nf_t_def
using assms r_result_total
by auto


Input: lemma resr_subdist: "(x \<rightarrow> y) \<squnion> (x \<rightarrow> z) \<le> x \<rightarrow> (y \<squnion> z)"

Output: by (metis sup_commute sup_least resr_subdist_var)


Input: theorem omega_comp_fix: "x ^ \<omega> * y = (x * (x ^ \<omega>) * y) \<sqinter> y"

Output:
apply (subst omega_fix)
by (simp add: inf_comp)


Input:
lemma eucl_truncate_down_le:
  "x \<le> y \<Longrightarrow> eucl_truncate_down w x \<le> (y::'a::executable_euclidean_space)"

Output:
using eucl_truncate_down
by (rule order.trans)


Input:
lemma d_isotone:
  "x \<le> y \<Longrightarrow> d(x) \<le> d(y)"

Output:
using d_dist_sup sup_right_divisibility
by force


Input:
lemma positively_responsiveI[intro]:
  assumes I: "\<And>P P' x y.
    \<lbrakk> profile A Is P; profile A Is P'; x \<in> A; y \<in> A;
      \<And>i. \<lbrakk> i \<in> Is; x \<^bsub>(P i)\<^esub>\<prec> y \<rbrakk> \<Longrightarrow> x \<^bsub>(P' i)\<^esub>\<prec> y;
      \<And>i. \<lbrakk> i \<in> Is; x \<^bsub>(P i)\<^esub>\<approx> y \<rbrakk> \<Longrightarrow> x \<^bsub>(P' i)\<^esub>\<preceq> y;
      \<exists>k \<in> Is. (x \<^bsub>(P k)\<^esub>\<approx> y \<and> x \<^bsub>(P' k)\<^esub>\<prec> y) \<or> (y \<^bsub>(P k)\<^esub>\<prec> x \<and> x \<^bsub>(P' k)\<^esub>\<preceq> y);
      x \<^bsub>(scf P)\<^esub>\<preceq> y \<rbrakk>
     \<Longrightarrow> x \<^bsub>(scf P')\<^esub>\<prec> y"
  shows "positively_responsive scf A Is"

Output:
unfolding positively_responsive_def
by (blast intro: I)


Input:
lemma Lambert_W'_less_iff [simp]:
  "x \<in> {-exp(-1)..<0} \<Longrightarrow> y \<in> {-exp(-1)..<0} \<Longrightarrow> Lambert_W' x < Lambert_W' y \<longleftrightarrow> x > y"

Output:
using Lambert_W'_strict_antimono[of x y] Lambert_W'_strict_antimono[of y x]
by (cases x y rule: linorder_cases) auto


Input:
lemma cont2cont_foldl [simp, cont2cont]:
  fixes f :: "'a::cpo \<Rightarrow> 'b::cpo \<Rightarrow> 'c::cpo \<Rightarrow> 'b"
  fixes xs :: "'c list"
  fixes z :: "'a \<Rightarrow> 'b"
  assumes "cont (\<lambda>(x, y, z). f x y z)"
  assumes "cont z"
  shows "cont (\<lambda>x. foldl (f x) (z x) xs)"

Output:
using assms
by (induct xs rule: rev_induct) (auto simp: prod_cont_iff intro: cont_apply)


Input:
lemma fls_lr_inverse_zero:
  fixes x :: "'a::{ab_group_add,mult_zero}"
  and   y :: "'b::{comm_monoid_add,mult_zero,uminus}"
  shows "fls_left_inverse 0 x = fls_const x"
  and   "fls_right_inverse 0 y = fls_const y"

Output:
using fls_lr_inverse_const[of 0]
by auto


Input: lemma le_pow2[simp]: "x \<le> y \<Longrightarrow> x \<le> 2 ^ y"

Output: by (induct x arbitrary: y) (force simp add: Suc_le_eq order.strict_iff_order)+


Input: lemma ennreal_le_iff2: "ennreal x \<le> ennreal y \<longleftrightarrow> ((0 \<le> y \<and> x \<le> y) \<or> (x \<le> 0 \<and> y \<le> 0))"

Output: by (cases "0 \<le> y") (auto simp: ennreal_eq_0_iff ennreal_neg)


Input:
lemma closed_superdiagonal:
  "closed {(x,y) | x y. x \<ge> (y::('a::{linorder_topology}))}"

Output:
proof - have "{(x,y) | x y. x \<ge> (y::'a)} = UNIV - {(x,y) | x y. x < y}"
by auto then show ?thesis
using open_subdiagonal closed_Diff
by auto
qed


Input:
lemma vector_restrict_comp_conv:
  "vector x \<Longrightarrow> x \<sqinter> y \<le> x\<^sup>T * y"

Output: by (metis covector_inf_comp_3 eq_refl inf.sup_monoid.add_commute inf_top_right le_supE sup.orderE top_left_mult_increasing)


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

Output: by (metis order.antisym mult_assoc mult_right_isotone omega_simulation omega_unfold order_refl)


Input:
lemma Omega_sup_3:
  "(x \<squnion> y)\<^sup>\<Omega> = (x\<^sup>\<star> * y)\<^sup>\<Omega> * x\<^sup>\<Omega>"

Output:
apply (rule order.antisym)
apply (metis Omega_sum_unfold_1 Omega_induct eq_refl sup_commute)
by (simp add: Omega.circ_isotone Omega_sup mult_left_isotone star_below_Omega)


Input: lemma st_le: "x \<in> HFinite \<Longrightarrow> y \<in> HFinite \<Longrightarrow> x \<le> y \<Longrightarrow> st x \<le> st y"

Output: by (metis approx_le_bound approx_sym linear st_SReal st_approx_self st_part_Ex1)


Input: lemma into_WW_imp_ge: "y \<in> List.set (into_WW x ns) \<Longrightarrow> x \<le> y"

Output: by (induction ns arbitrary: x) fastforce+


Input: lemma rank_mono: "x \<le> y \<Longrightarrow> rank x \<le> rank y"

Output: by (metis HPow_iff Ord_rank Vset_succ Vset_succ_rank_le dual_order.trans le_Vset_rank)


Input: lemma vdisjnt_vinsert_left: "vdisjnt (vinsert a X) Y \<longleftrightarrow> a \<notin>\<^sub>\<circ> Y \<and> vdisjnt X Y"

Output: by (metis vdisjnt_iff vdisjnt_sym vinsertE1 vinsertI2 vinsert_iff)


Input: lemma adjacent_card: "x \<sim> y \<Longrightarrow> card x = card y"

Output:
unfolding adjacent_def facetrel_def
by (cases "finite x" "x=y" rule: two_cases) auto


Input: lemma subterm_size_lt: "x \<sqsubset> y \<Longrightarrow> size x < size y"

Output:
using not_less_eq size_list_estimation
by (induct y, simp, fastforce)


Input:
lemma schroeder_1:
  "x * y \<sqinter> z = bot \<longleftrightarrow> x\<^sup>T * z \<sqinter> y = bot"

Output:
using abel_semigroup.commute comp_left_conjugate conjugate_def inf.abel_semigroup_axioms
by fastforce


Input:
lemma pell_square_solution_nat_iff:
  fixes x y :: nat
  shows "x ^ 2 = 1 + D * y ^ 2  \<longleftrightarrow>  x = 1 \<and> (D = 0 \<or> y = 0)"

Output:
using pell_square_solution_nat_aux[of x y]
by (cases "D = 0") auto


Input:
lemma atan2_bounded:
  shows "-pi \<le> atan2 y x \<and> atan2 y x < pi"

Output:
using arctan_bounded[of "y/x"] zero_le_arctan_iff[of "y/x"] arctan_le_zero_iff[of "y/x"] zero_less_arctan_iff[of "y/x"] arctan_less_zero_iff[of "y/x"]
using divide_neg_neg[of y x] divide_neg_pos[of y x] divide_pos_pos[of y x] divide_pos_neg[of y x] unfolding atan2_def
by (simp (no_asm_simp)) auto


Input: lemma mult_DirProd': "x \<otimes>\<^bsub>(G \<times>\<times> H)\<^esub> y = (fst x \<otimes>\<^bsub>G\<^esub> fst y, snd x \<otimes>\<^bsub>H\<^esub> snd y)"

Output: by (subst mult_DirProd [symmetric]) simp


Input:
lemma at_lst_asgd_not_ge:
  assumes "carrier \<noteq> {}"
  assumes "x \<in> carrier" and "y \<in> carrier"
  assumes "x \<notin> at_least_as_good y carrier relation"
  shows "\<not> x \<succeq> y"

Output: by (metis (no_types, lifting) CollectI assms(2) assms(4) at_least_as_good_def)


Input:
lemma d_commutative:
  "d(x) * d(y) = d(y) * d(x)"

Output: by (metis ils.il_inf_associative order.antisym d_export d_mult_d d_mult_sub d_one d_restrict_equals mult_isotone mult_left_one)


Input:
lemma vector_meet:
  "x * top \<sqinter> y \<le> d(x) * y"

Output: by (metis d_galois d_mult_sub inf.sup_monoid.add_commute inf.sup_right_isotone meet_domain_top)


Input:
lemma list_set_insert[param]:
    assumes "y \<notin> Y"
    assumes "(x, y) \<in> A" "(xs, Y) \<in> \<langle>A\<rangle> list_set_rel"
    shows "(x # xs, insert y Y) \<in> \<langle>A\<rangle> list_set_rel"

Output:
using assms unfolding list_set_rel_def relcomp_unfold in_br_conv
by (auto) (metis refine_list(2)[param_fo] distinct.simps(2) list.simps(15))


Input:
lemma homeomorphic_path_connected_space:
   "X homeomorphic_space Y \<Longrightarrow> path_connected_space X \<longleftrightarrow> path_connected_space Y"

Output: by (meson homeomorphic_path_connected_space_imp homeomorphic_space_sym)


Input:
lemma pth_c:
  fixes x :: "'a::real_normed_vector"
  shows "scaleR c x + scaleR d y \<equiv> scaleR d y + scaleR c x"
    and "(scaleR c x + z) + scaleR d y \<equiv> scaleR d y + (scaleR c x + z)"
    and "scaleR c x + (scaleR d y + z) \<equiv> scaleR d y + (scaleR c x + z)"
    and "(scaleR c x + w) + (scaleR d y + z) \<equiv> scaleR d y + ((scaleR c x + w) + z)"

Output: by (simp_all add: algebra_simps)


Input:
lemma norm_diff_triangle_less: "norm (x - z) < e1 + e2"
  if "norm (x - y) < e1"  "norm (y - z) < e2"

Output:
proof - have "norm (x - z) \<le> norm (x - y) + norm (y - z)"
by (metis norm_diff_triangle_ineq add_diff_cancel_left' diff_diff_eq2) with that show ?thesis
by auto
qed


Input: lemma ordinal_le_timesR [simp]: "0 < y \<Longrightarrow> x \<le> x * (y::ordinal)"

Output: by (drule ordinal_times_monoR[OF oSuc_leI], simp)


Input:
lemma cont_compose2:
  assumes "\<And> y. cont (\<lambda> x. c x y)"
  assumes "\<And> x. cont (\<lambda> y. c x y)"
  assumes "cont f"
  assumes "cont g"
  shows "cont (\<lambda>x. c (f x) (g x))"

Output: by (intro cont_apply[OF assms(4) assms(2)] cont2cont_fun[OF cont_compose[OF _ assms(3)]] cont2cont_lambda[OF assms(1)])


Input: lemma prod_star_closure: "x \<le> z\<^sup>\<star> \<Longrightarrow> y \<le> z\<^sup>\<star> \<Longrightarrow> x \<cdot> y \<le> z\<^sup>\<star>"

Output: by (metis mult_isol_var star_trans_eq)


Input:
lemma b_rel_subtyping_merge[sepref_frame_merge_rules]:
  assumes "hn_ctxt A x y \<or>\<^sub>A hn_ctxt A' x y \<Longrightarrow>\<^sub>t hn_ctxt Am x y"
  shows "hn_ctxt (b_assn A P) x y \<or>\<^sub>A hn_ctxt (b_assn A' P') x y \<Longrightarrow>\<^sub>t hn_ctxt (b_assn Am (\<lambda>x. P x \<or> P' x)) x y"

Output:
using assms unfolding hn_ctxt_def b_assn_def entailst_def entails_def
by (fastforce simp: vassn_tag_def) \<comment> \<open>Simplified forms\<close>


Input:
lemma enumdom_nonempty_domain:
  assumes "\<phi> i x\<^sub>0 \<down>"
  shows "\<And>y. enumdom i y \<down>"
   and "\<And>x. \<phi> i x \<down> \<longleftrightarrow> (\<exists>y. enumdom i y \<down>= x)"

Output:
using assms r_enumdom_nonempty_domain phi_def
by metis+


Input:
lemma sublens'_prop2:
  assumes "vwb_lens X" "X \<subseteq>\<^sub>L' Y"
  shows "get\<^bsub>X\<^esub> (put\<^bsub>Y\<^esub> s\<^sub>1 (get\<^bsub>Y\<^esub> s\<^sub>2)) = get\<^bsub>X\<^esub> s\<^sub>2"

Output:
using assms unfolding sublens'_def
by (metis lens_override_def vwb_lens_wb wb_lens_axioms_def wb_lens_def weak_lens.put_get)


Input: lemma gen_cong_symp[intro]: "gen_cong R x y \<Longrightarrow> gen_cong R y x"

Output:
unfolding gen_cong_def
by (auto dest: cong_equivp equivp_symp)


Input:
lemma has_field_derivative_Beta2 [derivative_intros]:
  assumes "y \<notin> \<int>\<^sub>\<le>\<^sub>0" "x + y \<notin> \<int>\<^sub>\<le>\<^sub>0"
  shows   "((\<lambda>y. Beta x y) has_field_derivative (Beta x y * (Digamma y - Digamma (x + y))))
               (at y within A)"

Output:
using has_field_derivative_Beta1[of y x A] assms
by (simp add: Beta_commute add_ac)


Input:
lemma transT_MtransT[simp]:
assumes "cf \<rightarrow>t s'"
shows "cf \<rightarrow>*t s'"

Output: by (metis PL.MtransC_Refl PL.MtransT.intros assms)


Input: lemma init_s : "t \<le> 0 \<Longrightarrow> s t = s0"

Output:
using decel nonneg_vel
by (simp add: divide_simps s_def)


Input: lemma eta_preserves_typ_of: "t \<rightarrow>\<^sub>\<eta> t' \<Longrightarrow> typ_of t = Some \<tau> \<Longrightarrow> typ_of t' = Some \<tau>"

Output:
using eta_preserves_typ_of1 typ_of_def
by simp


Input:
theorem avl_insert_auto: "avl t \<Longrightarrow>
  avl(insert x t) \<and> height (insert x t) \<in> {height t, height t + 1}"

Output:
apply (induction t rule: tree2_induct)
apply (auto simp: balL_def balR_def node_def max_absorb2 split!: if_split tree.split) done


Input: lemma fresh_trans_tm_iff [simp]: "i \<sharp> trans_tm e t \<longleftrightarrow> i \<sharp> t \<or> i \<in> atom ` set e"

Output: by (induct t rule: tm.induct, auto simp: lookup_fresh fresh_at_base)


Input: lemma type_subst_idle[simp]: "atom y \<sharp> t \<Longrightarrow> subst_type t s y = t"

Output: by (nominal_induct t avoiding: s y rule: ty.strong_induct) (auto simp: fresh_Pair fresh_at_base)


Input:
lemma vpairwise_vsubset:
  assumes "vpairwise P S" and "T \<subseteq>\<^sub>\<circ> S"
  shows "vpairwise P T"

Output:
using assms
by (metis less_eq_V_def subset_eq vpairwiseD(2) vpairwiseI)


Input:
lemma (in dp_consistency) comp\<^sub>T_transfer[transfer_rule]:
  "crel_vs ((R1 ===>\<^sub>T R2) ===>\<^sub>T (R0 ===>\<^sub>T R1) ===>\<^sub>T (R0 ===>\<^sub>T R2)) comp comp\<^sub>T"

Output:
apply memoize_combinator_init subgoal premises IH [transfer_rule]
by memoize_unfold_defs transfer_prover done


Input:
lemma subst_trm_eqvt'[eqvt]:
  fixes pi::"vrs prm"
  and   t::"trm"
  shows "pi\<bullet>(t[x \<mapsto> u]) = (pi\<bullet>t)[(pi\<bullet>x) \<mapsto> (pi\<bullet>u)]"

Output: by (nominal_induct t avoiding: x u rule: trm.strong_induct) (perm_simp add: fresh_left)+


Input:
lemma unifiers_occur_left_not_Var:
  "x \<in> vars_term t \<Longrightarrow> t \<noteq> Var x \<Longrightarrow> unifiers (insert (Var x, t) E) = {}"

Output:
using unifiers_occur_left_is_Fun [of x t]
by (cases t) simp_all


Input:
lemma is_type_ground_type:
  "is_type P T \<Longrightarrow> is_type P (ground_type T)"

Output: by(induct T)(auto, metis is_type_ArrayD is_type_array)


Input:
lemma rel_interior_eq_between:
  fixes S T :: "('m::euclidean_space) set"
  assumes "convex S" "convex T"
  shows "(rel_interior S = rel_interior T) \<longleftrightarrow> (rel_interior S \<le> T \<and> T \<le> closure S)"

Output: by (metis assms closure_eq_between convex_closure_rel_interior convex_rel_interior_closure)


Input:
lemma guard_continuous:
  assumes "u \<turnstile> g" "u \<oplus> t \<turnstile> g" "0 \<le> (t'::'t::time)" "t' \<le> t"
  shows "u \<oplus> t' \<turnstile> g"

Output:
using assms
by (induction g; auto 4 3 simp: cval_add_def order_le_less_subst2 order_subst2 add_increasing2 intro: less_le_trans )


Input: lemma loose_bvar1_eta_norm: "loose_bvar1 t lev \<Longrightarrow> loose_bvar1 (eta_norm t) lev"

Output: by (induction t arbitrary: lev rule: eta_norm.induct) (use loose_bvar1_decr''' in \<open>(fastforce split: term.splits nat.splits)+\<close>)


Input:
lemma id_apply:
  shows "(id \<Gamma>)<t> = t"

Output: by (nominal_induct t avoiding: \<Gamma> rule: trm.strong_induct) (auto simp add: id_maps id_fresh)


Input: lemma heron_step_real: "\<lbrakk>t > 0; n \<ge> 0\<rbrakk> \<Longrightarrow> (t + n/t) / 2 \<ge> sqrt n"

Output:
using arith_geo_mean_sqrt[of t "n/t"]
by simp


Input:
theorem Par_BisT[simp]:
assumes "c1 \<approx>T d1" and "c2 \<approx>T d2"
shows "Par c1 c2 \<approx>T Par d1 d2"

Output:
using assms thetaParTT_BisT unfolding thetaParTT_def
by blast


Input:
lemma ins_tree_rank_bound:
  assumes "t' \<in> set (ins_tree t ts)"
  assumes "\<forall>t'\<in>set ts. rank t\<^sub>0 < rank t'"
  assumes "rank t\<^sub>0 < rank t"
  shows "rank t\<^sub>0 < rank t'"

Output:
using assms
by (induction t ts rule: ins_tree.induct) (auto split: if_splits)


Input:
lemma term_ok_mk_eq_same_typ:
  assumes "wf_theory \<Theta>"
  assumes "term_ok \<Theta> (mk_eq s t)"
  shows "typ_of s = typ_of t"

Output:
using assms
by (cases \<Theta> rule: theory_full_exhaust) (fastforce simp add: wt_term_def typ_of_def bind_eq_Some_conv tinstT_def)


Input:
lemma homeomorphic_AR_iff_AR:
  fixes S :: "'a::euclidean_space set" and T :: "'b::euclidean_space set"
  shows "S homeomorphic T \<Longrightarrow> AR S \<longleftrightarrow> AR T"

Output: by (metis AR_homeomorphic_AR homeomorphic_sym)


Input: lemma lc_Abs_iff_body: "lc (\<Lambda>\<langle>T\<rangle> t) \<longleftrightarrow> body T t"

Output:
unfolding body_def
by (subst lc.simps) simp


Input: lemma Sem_no_zero_height_derivsAux: "\<forall> s t. ((s, c \<rightarrow>\<^sub>0 t) \<longrightarrow> False)"

Output: by (induct_tac c, auto elim: Sem_eval_cases)


Input:
lemma ZObis_transT2[consumes 3, case_names Match MatchO MatchS]:
assumes 0: "c \<approx>01 d" and "s \<approx> t" and "(d,t) \<rightarrow>t t'"
and "\<And> s'. \<lbrakk>(c,s) \<rightarrow>t s'; s' \<approx> t'\<rbrakk> \<Longrightarrow> thesis"
and "\<And> c' s'. \<lbrakk>(c,s) \<rightarrow>c (c',s'); s' \<approx> t'; discr c'\<rbrakk> \<Longrightarrow> thesis"
and "\<lbrakk>s \<approx> t'; discr c\<rbrakk> \<Longrightarrow> thesis"
shows thesis

Output:
using assms ZObis_matchT_ZO_rev[OF 0] ZObis_Sym unfolding matchT_ZO_def2
by blast


Input:
theorem progress:
  assumes a: "[] \<turnstile> t : T"
  shows "(\<exists>t'. t \<longrightarrow>cbv t') \<or> (val t)"

Output:
using a
by (induct \<Gamma>\<equiv>"[]::tctx" t T) (auto dest!: canonical_tINT intro!: cbv.intros gr0I)


Input:
lemma term_variants_pred_inv':
  assumes "term_variants_pred P (Fun f T) t"
  shows "is_Fun t"
    and "length T = length (args t)"
    and "\<And>i. i < length T \<Longrightarrow> term_variants_pred P (T ! i) (args t ! i)"
    and "f \<noteq> the_Fun t \<Longrightarrow> the_Fun t \<in> set (P f)"
    and "P \<equiv> (\<lambda>_. [])(g := [h]) \<Longrightarrow> f \<noteq> the_Fun t \<Longrightarrow> f = g \<and> the_Fun t = h"

Output:
using assms
by (auto elim: term_variants_pred.cases)


Input:
lemma range_varsE [elim]:
  assumes "x \<in> range_vars \<sigma>"
    and "\<And>t. x \<in> vars_term t \<Longrightarrow> t \<in> subst_range \<sigma> \<Longrightarrow> P"
  shows "P"

Output:
using assms
by (auto simp: range_vars_def)


Input: lemma stopping_time_eq_const: "stopping_time F T \<Longrightarrow> Measurable.pred (F t) (\<lambda>\<omega>. T \<omega> = t)"

Output:
unfolding eq_iff
using stopping_time_less_const[of T t]
by (intro pred_intros_logic stopping_time_le_const) (auto simp: not_less[symmetric] )


Input:
lemma closure_of_minimal:
   "\<lbrakk>S \<subseteq> T; closedin X T\<rbrakk> \<Longrightarrow> (X closure_of S) \<subseteq> T"

Output: by (metis closure_of_eq closure_of_mono)


Input: lemma lift_lemma [simp]: \<open>\<lparr>E\<langle>0:x\<rangle>, F\<rparr> (\<^bold>\<up>t) = \<lparr>E, F\<rparr> t\<close>

Output: by (induct t) (auto cong: map_cong)


Input:
lemma isin_bst:
  assumes "bst t"
  shows   "isin t x \<longleftrightarrow> x \<in> set_tree t"

Output:
using assms
by (subst isin_set) (auto simp: bst_iff_sorted_wrt_less)


Input:
lemma solution_preflect:
  assumes "t0 \<in> T"
  assumes sol: "(x solves_ode f) T X"
  shows "((\<lambda>t. x (preflect t0 t)) solves_ode (\<lambda>t x. - f (preflect t0 t) x)) (preflect t0 ` T) X"

Output:
using sol \<open>t0 \<in> T\<close>
by (simp_all add: preflect_def image_image preflect_solution[of t0])


Input:
lemma map_transform_Cons:
  "map_transform t ae ((x,e)# \<Gamma>) = (x, lift_transform t (ae x) e) #  (map_transform t ae \<Gamma>)"

Output:
unfolding map_transform_def
by simp


Input: lemma no_loose_bvar_subst_bvs1'_unchanged: "\<not> loose_bvar t lev \<Longrightarrow> subst_bvs1' t lev args = t"

Output: by (induction t lev args rule: subst_bvs1'.induct) auto


Input:
lemma continuous_on_cases_1:
  fixes s :: "real set"
  assumes "continuous_on {t \<in> s. t \<le> a} f"
      and "continuous_on {t \<in> s. a \<le> t} g"
      and "a \<in> s \<Longrightarrow> f a = g a"
    shows "continuous_on s (\<lambda>t. if t \<le> a then f(t) else g(t))"

Output:
using assms
by (auto intro: continuous_on_cases_le [where h = id, simplified])


Input:
lemma transaction_bvars_no_Value_type:
  assumes "admissible_transaction T"
    and "x \<in> bvars_transaction T"
  shows "\<not>TAtom Value \<sqsubseteq> \<Gamma>\<^sub>v x"

Output:
using assms transaction_no_bvars(2)
by blast


Input:
lemma Int_filters:
  fixes F and T (structure) assumes "filter F T"
  fixes E assumes "filter E T"
  shows "F \<inter> E \<in> Filters"

Output:
proof - interpret filter F T
by fact interpret filter E T
by fact show ?thesis
by auto
qed


Input: lemma path_component: "path_component S x y \<longleftrightarrow> (\<exists>t. path_connected t \<and> t \<subseteq> S \<and> x \<in> t \<and> y \<in> t)"

Output:
apply (intro iffI)
apply (metis path_connected_path_image path_defs(5) pathfinish_in_path_image pathstart_in_path_image)
using path_component_of_subset path_connected_component
by blast


Input:
lemma subst_wellformed:
  assumes "wellformed' n t" "fmpred (\<lambda>_. wellformed) env"
  shows "wellformed' n (subst t env)"

Output:
using assms
by (induction t arbitrary: n) (auto split: option.splits intro: wellformed_inc)


Input:
lemma narrow_PrimT2: "G\<turnstile>S\<succ>PrimT pt \<Longrightarrow>
                                  \<exists>t. S=PrimT t \<and> G\<turnstile>PrimT t\<preceq>PrimT pt"

Output: by (ind_cases "G\<turnstile>S\<succ>PrimT pt")


Input:
lemma proves_eq_transitive:
  assumes "wf_theory \<Theta>"
  assumes "term_ok \<Theta> s"
  assumes "term_ok \<Theta> t"
  assumes "term_ok \<Theta> u"
  assumes "typ_of s = typ_of t" "typ_of t = typ_of u"
  assumes ctxt: "finite \<Gamma>" "\<forall>A\<in>\<Gamma>. term_ok \<Theta> A" "\<forall>A\<in>\<Gamma>. typ_of A = Some propT"
  shows "\<Theta>, \<Gamma> \<turnstile> mk_eq s t \<longmapsto> mk_eq t u \<longmapsto> mk_eq s u"

Output: by (subst unsimp_context) (use assms proves_eq_transitive_pre weaken_proves_set in blast)


Input:
lemma paths_many_calls_subset:
  "t \<sqsubseteq> many_calls x \<otimes>\<otimes> without x t"

Output: by (metis (full_types) below_set_def paths_many_calls_subset paths_mono_iff)


Input:
lemma reduction_deterministic:
  assumes "t \<rightarrow>\<^sub>v t'"
  assumes "t \<rightarrow>\<^sub>v t''"
  shows "t'' = t'"

Output:
using assms
by (induct arbitrary: t'') (blast dest: reduction_val elim: reduction_inv)+


Input: lemma SMP_empty[simp]: "SMP {} = {}"

Output:
proof (rule ccontr) assume "SMP {} \<noteq> {}" then obtain t where "t \<in> SMP {}"
by auto thus False
by (induct t rule: SMP.induct) auto
qed


Input:
lemma subst_typ'_no_tvs_unchanged:
  "\<forall>(f, s) \<in> set insts . f \<notin> tvs t \<Longrightarrow> subst_typ' insts t = t"

Output: by (induction t) (use subst_typ_no_tvsT_unchanged in \<open>fastforce+\<close>)


Input:
lemma insert3_insert2_d:
  "bal_i (n+dl) (height t) \<Longrightarrow> insert3_d x (t,n,dl) = insert2_d x (t,n,dl)"

Output: by(simp add: ins3_ins2 split: up2.split)


Input: lemma term_fresh_subst[simp]: "atom x \<sharp> t \<Longrightarrow> atom x \<sharp> s \<Longrightarrow> (atom (x::var)) \<sharp> t[s / y]"

Output: by (nominal_induct t avoiding: s y rule: term.strong_induct) (auto)


Input: lemma var_dist_cong: "s \<leftrightarrow> t \<Longrightarrow> var_dist vs s \<leftrightarrow> var_dist vs t"

Output: by (induction vs arbitrary: s t) auto


Input: lemma widen_Array_Array: "G\<turnstile>T.[]\<preceq>T'.[] \<Longrightarrow> G\<turnstile>T\<preceq>T'"

Output:
apply (drule widen_Array)
apply auto done


Input: lemma splay_Leaf_iff[simp]: "(splay a t = Leaf) = (t = Leaf)"

Output: by(induction a t rule: splay.induct) (auto split: tree.splits)


Input:
lemma Wbis_transT[consumes 3, case_names Match MatchO]:
assumes 0: "c \<approx>w d" and "s \<approx> t" and "(c,s) \<rightarrow>t s'"
and "\<And> t'. \<lbrakk>(d,t) \<rightarrow>*t t'; s' \<approx> t'\<rbrakk> \<Longrightarrow> thesis"
and "\<And> d' t'. \<lbrakk>(d,t) \<rightarrow>*c (d',t'); s' \<approx> t'; discr d'\<rbrakk> \<Longrightarrow> thesis"
shows thesis

Output:
using assms Wbis_matchT_M[OF 0] unfolding matchT_M_def
by blast


Input:
lemma even_mirror_traverse_tree [simp]:
  "root (traverse_tree path (even_mirror t)) = root (traverse_tree (even_mirror_path path) t)"
  and odd_mirror_traverse_tree [simp]:
  "root (traverse_tree path (odd_mirror t)) = root (traverse_tree (odd_mirror_path path) t)"

Output: by (induct path arbitrary: t) (simp_all split: dir.splits)


Input:
lemma subtype_refl: \<comment> \<open>A.1\<close>
  "\<Gamma> \<turnstile>\<^sub>w\<^sub>f \<Longrightarrow> \<Gamma> \<turnstile>\<^sub>w\<^sub>f T \<Longrightarrow> \<Gamma> \<turnstile> T <: T"

Output: by (induct T arbitrary: \<Gamma>) (blast intro: subtyping.intros wf_Nil wf_TVarB elim: well_formed_cases)+


Input: theorem hinv_insrt: "hinv t \<Longrightarrow> hinv (insrt x t)"

Output: by (induct t) (simp_all add: Let_def height_hinv hinv_l_bal hinv_r_bal)


Input:
lemma alternating_list_split:
  "alternating_list (m+n) s t = alternating_list m s t @
    (if even m then alternating_list n s t else alternating_list n t s)"

Output:
using alternating_list_SucSuc_ConsCons[of _ s]
by (induct n rule: nat_induct_step2) auto


Input:
lemma subst_bvs1_step:
  assumes "\<not> loose_bvar t lev"
  shows "subst_bvs1 t lev (args@[u]) = subst_bv1 (subst_bvs1 t lev args) lev u"

Output:
using assms
by (induction t arbitrary: lev args u) auto


Input:
lemma finite_dimensional_vector_space_pair_with_imp_finite_dimensional_vector_space_with[explicit_ab_group_add]:
  "vector_space_on_with S (+) (-) uminus 0 s"
  "finite_dimensional_vector_space_on_with T (+) (-) uminus 0 t c"
  "vector_space_on_with T (+) (-) uminus 0 t"
  "finite_dimensional_vector_space_on_with T (+) (-) uminus 0 t c"
  if "finite_dimensional_vector_space_pair_on_with S T (+) (-) uminus 0 s b (+) (-) uminus 0 t c"

Output:
using that unfolding finite_dimensional_vector_space_pair_on_with_def
by (simp_all add: finite_dimensional_vector_space_on_with_def)


Input:
lemma addr_loc_type_fun:
  "\<lbrakk> P,h \<turnstile> a@al : T; P,h \<turnstile> a@al : T' \<rbrakk> \<Longrightarrow> T = T'"

Output: by(auto elim!: addr_loc_type.cases dest: has_field_fun)


Input:
lemma setops\<^sub>s\<^sub>s\<^sub>t\<^sub>p_member_iff:
  "(t,s) \<in> setops\<^sub>s\<^sub>s\<^sub>t\<^sub>p x \<longleftrightarrow>
    (x = Insert t s \<or> x = Delete t s \<or> (\<exists>ac. x = InSet ac t s) \<or>
     (\<exists>X F F'. x = NegChecks X F F' \<and> (t,s) \<in> set F'))"

Output: by (cases x) auto


Input:
lemma
ZObis_matchC_ZO_rev: "\<And> s t. s \<approx>01 t \<Longrightarrow> matchC_ZO ZObis t s"
and
ZObis_matchT_ZO_rev: "\<And> s t. s \<approx>01 t \<Longrightarrow> matchT_ZO t s"

Output:
using ZObis_step ZObis_sym unfolding sym_def
by blast+


Input:
lemma tObsC_abs_conv:
  "(u, v) \<in> tObsC_abs t
    \<longleftrightarrow> (\<exists>t'. t' \<in> SPR.jkbpC \<and> tObsC t' = tObsC t \<and> u = tFirst t' \<and> v = tLast t')"

Output:
unfolding tObsC_abs_def
by blast


Input:
lemma sum_le:
  fixes x :: "'a::ordered_ab_group_add"
  shows "x + t \<le> 0 \<equiv> x \<le> - t"

Output:
using le_diff_eq[where a= x and b=t and c=0]
by simp


Input: lemma mset_del_min: "mset_tree (del_min t) = mset_tree t - {# get_min t #}"

Output: by (cases t) (auto simp: mset_merge)


Input:
lemma convex[intro, simp]: "convex T"
  and connected[intro, simp]: "connected T"

Output: by (simp_all add: interval is_interval_connected is_interval_convex )


Input: lemma add_order_add_eq1: "add_order (s+t) = 1 \<Longrightarrow> t = -s"

Output:
using add_order[of "s+t"]
by (simp add: minus_unique)


Input: lemma design_iso_points_indices_eq: "source.point_indices t = target.point_indices t"

Output:
using inverse_design_isomorphism design_isomorphism.design_iso_points_indices_imp design_iso_points_indices_imp
by blast


Input:
lemma member_remove [simp]:
  "member (remove (x :: 'a) t) = (member t)(x := False)"

Output: by transfer (simp add: linorder.rbt_lookup_rbt_delete[OF set_linorder] ID_ccompare_neq_None fun_eq_iff)


Input:
lemma logical_symmetry:
  assumes a: "\<Gamma> \<turnstile> s is t : T"
  shows "\<Gamma> \<turnstile> t is s : T"

Output:
using a
by (nominal_induct arbitrary: \<Gamma> s t rule: ty.strong_induct) (auto simp add: algorithmic_symmetry)


Input:
lemma openin_Times:
  "openin (top_of_set S) S' \<Longrightarrow> openin (top_of_set T) T' \<Longrightarrow>
    openin (top_of_set (S \<times> T)) (S' \<times> T')"

Output:
unfolding openin_open
using open_Times
by blast


Input:
lemma cong_red_in_ctx:
  assumes a: "t \<longrightarrow>o t'"
  shows "E\<lbrakk>t\<rbrakk> \<longrightarrow>o E\<lbrakk>t'\<rbrakk>"

Output:
using a
by (induct E rule: ctx.induct) (auto)


Input:
lemma reduction_fresh:
  fixes x::"name"
  assumes r: "t \<mapsto> t'"
  shows "x \<sharp> t \<Longrightarrow> x \<sharp> t'"

Output:
using r
by(nominal_induct t t' avoiding: x rule: reduction.strong_induct) (auto simp add: abs_fresh fresh_fact fresh_atm)


Input:
lemma filtrationI:
  assumes "\<forall>t. subalgebra M (F t)"
  and "\<forall>s t. s \<le> t \<longrightarrow> subalgebra (F t) (F s)"
shows "filtration M F"

Output:
unfolding filtration_def
using assms
by simp


Input: lemma lift_def: "lift t n = incr_bv 1 n t"

Output: by (induction t n rule: lift.induct) auto


Input: lemma OrdP_sf [iff]: "Sigma_fm (OrdP t)"

Output:
proof - obtain z::name and y::name where "atom z \<sharp> t" "atom y \<sharp> (t, z)"
by (metis obtain_fresh) thus ?thesis
by (auto simp: OrdP.simps)
qed


Input:
lemma THE_addr_loc_type:
  "P,h \<turnstile> a@al : T \<Longrightarrow> (THE T. P,h \<turnstile> a@al : T) = T"

Output: by(rule the_equality)(auto dest: addr_loc_type_fun)


Input:
lemma matches_iff:
  "matches t p \<longleftrightarrow> (\<exists>\<sigma>. p \<cdot> \<sigma> = t)"

Output:
using match_list_sound [of _ "[(p,t)]"] and match_list_complete [of _ "[(p,t)]"] unfolding matches_def matchers_def
by (force simp: split: option.splits)


Input: lemma conf_widen: "P,h \<turnstile> v :\<le> T \<Longrightarrow> P \<turnstile> T \<le> T' \<Longrightarrow> P,h \<turnstile> v :\<le> T'"

Output:
apply (unfold conf_def)
apply (induct v)
apply (auto intro: widen_trans) done


Input: lemma split_invar: "invar t \<Longrightarrow> split t = t"

Output: by(cases t rule: split.cases) clarsimp+


Input: lemma simptm_nb[simp]: "tmbound n t \<Longrightarrow> tmbound n (simptm t)"

Output: by (induct t rule: simptm.induct) (auto simp add: Let_def)


Input: lemma fv_subst_subset: "x \<in> fv t \<Longrightarrow> fv (\<theta> x) \<subseteq> fv (t \<cdot> \<theta>)"

Output: by (metis fv_subset image_eqI subst_apply_fv_unfold)


Input:
lemma prv_pls_suc_zer:
"t \<in> atrm \<Longrightarrow> prv (eql (pls t (suc zer)) (suc t))"

Output: by (metis (no_types, hide_lams) atrm.atrm_pls atrm_imp_trm pls prv_eql_trans prv_pls_suc prv_pls_zer prv_suc_cong suc zer_atrm)


Input:
lemma setdist_eq_0_closed_compact:
  assumes S: "closed S" and T: "compact T"
    shows "setdist S T = 0 \<longleftrightarrow> S = {} \<or> T = {} \<or> S \<inter> T \<noteq> {}"

Output:
using setdist_eq_0_compact_closed [OF T S]
by (metis Int_commute setdist_sym)


Input: lemma mset_union_diff_comm: "t \<in># S \<Longrightarrow> T + (S - {#t#}) = (T + S) - {#t#}"

Output:
proof - assume "t \<in># S" then obtain S' where S: "S = add_mset t S'"
by (metis insert_DiffM) then show ?thesis
by auto
qed


Input:
lemma subtype_entailment:
  "t \<le>:\<^sub>P t' \<Longrightarrow> P' \<turnstile> P \<Longrightarrow> t \<le>:\<^sub>P' t'"

Output: apply(auto simp: subtype_def intro: un_pred_entailment_mono) done


Input: lemma type_universe_nonempty[simp]: "type_universe t \<noteq> {}"

Output: by (induction t) (auto intro: val_type.simps simp: type_universe_def)


Input:
lemma perm_ty[simp]:
  fixes T::"ty"
  and   pi::"name prm"
  shows "pi\<bullet>T = T"

Output: by (induct T rule: ty.induct) (simp_all)


Input:
lemma dist_P_le:
  assumes y: "y \<in> T \<rightarrow>\<^sub>C X" and z: "z \<in> T \<rightarrow>\<^sub>C X"
  assumes le: "\<And>t. tmin \<le> t \<Longrightarrow> t \<le> tmax \<Longrightarrow> dist (P_inner y t) (P_inner z t) \<le> R"
  assumes "0 \<le> R"
  shows "dist (P y t) (P z t) \<le> R"

Output: by (cases "t \<le> tmin"; cases "t \<ge> tmax") (auto simp: P_eqs y z not_le intro!: le)


Input: theorem RPO_S_subst: "(s,t) \<in> RPO_S \<Longrightarrow> (s \<cdot> \<sigma>, t \<cdot> \<sigma>) \<in> RPO_S" for \<sigma> :: "('f,'a)subst"

Output: using WPO_S_subst unfolding rpo_eq_wpo .


Input:
lemma tSplice_envAction:
  assumes tLen: "tLength t = tLength t'"
  shows "envAction (tLast (t \<^bsub>\<^esub>\<bowtie>\<^bsub>a\<^esub> t')) = envAction (tLast t)"

Output:
unfolding envAction_def
using tSplice_es[OF tLen] tSplice_pubActs[OF tLen]
by simp


Input:
lemma ts_lose_ack_st1ts:
  assumes "ts lose"
         and "lose t = [True]  \<longrightarrow>  ack t = [x]  \<and> st_out t = x"
         and "lose t = [False] \<longrightarrow>  ack t = [y]  \<and> st_out t = y"
  shows "ack t = [st_out t]"

Output:
using assms
by (metis ts_bool_False)


Input:
lemma ex_cm_imp_conds:
  assumes "\<exists>c'. next_change_multiplicity' c c' loc t n"
  shows "\<exists>t'. t' \<in>\<^sub>A frontier (c_imp c loc) \<and> t' \<le> t" "n \<noteq> 0"

Output:
using assms
by (auto simp: next_change_multiplicity'_def)


Input:
lemma leg0_prj_in_hom:
    shows "\<guillemotleft>T.leg0 \<cdot> \<p>\<^sub>0[S.leg0, T.leg1] : S.leg0 \<down>\<down> T.leg1 \<rightarrow> C.cod (Leg0 T)\<guillemotright>"

Output:
using S.is_span T.is_span C.prj0_in_hom [of "Leg0 S" "Leg1 T"] composable
by auto


Input:
lemma
  sup_existence_maximal:
  assumes "\<And>t. t0 \<le> t \<Longrightarrow> t \<in> existence_ivl t0 x0 \<Longrightarrow> flow t0 x0 t \<in> K"
  assumes "compact K" "K \<subseteq> X"
  assumes "bdd_above (existence_ivl t0 x0)"
  shows "Sup (existence_ivl t0 x0) \<notin> T"

Output:
using flow_leaves_compact_ivl_right[of K] assms
by force


Input:
lemma delete2_def2:
  "delete2 x (t,n,dl) =
  (let t' = del x t in
   case t' of
    None \<Rightarrow> (t,n,dl) |
    Some t' \<Rightarrow> (let n' = n-1; dl' = dl + 1
      in if bal_d n' dl' then (t',n',dl')
         else let t'' = bal_tree n' t' in (t'', n', 0)))"

Output:
using val_cong[OF delete2_tm.simps(1)]
by(simp only: delete2_def ins3_def del_def bal_tree_def val_simps option.case_distrib[of val])


Input:
lemma fresh_ssubst':
  assumes "finite V" "atom i \<sharp> t" "atom (p \<bullet> i) \<sharp> t"
    shows "atom i \<sharp> ssubst t V F"

Output:
using assms
by (induct t rule: tm.induct) (auto simp: F_unfold fresh_permute_left pinv)


Input: lemma finite_leaves: "finite (leaves i t)"

Output: by(induction i t rule: leaves.induct) auto


Input: lemma a_insert: "T_insert a t + \<Phi>(skew_heap.insert a t) - \<Phi> t \<le> 3 * log 2 (size1 t + 2) + 2"

Output:
using a_merge[of "Node Leaf a Leaf" "t"]
by (simp add: numeral_eq_Suc T_insert_def rh_def)


Input: lemma set_split_bst1: "bst t \<Longrightarrow> set_tree (fst (split_bst x t)) = {y \<in> set_tree t. y < x}"

Output: by (induction t) (auto split: prod.splits)


Input:
lemma not_final_thread_deadlocked_final_thread [iff]:
  "thr s t = \<lfloor>xln\<rfloor> \<Longrightarrow> not_final_thread s t \<or> t \<in> deadlocked s \<or> final_thread s t"

Output: by(auto simp add: not_final_thread_final_thread_conv[symmetric])


Input:
lemma fsize_finsert_in[simp]:
  assumes v12_t: "(v1,v2) |\<in>| t" shows "fsize (finsert (v1,v2) t) = fsize t"

Output:
proof - from v12_t have "finsert (v1,v2) t = t"
by auto from this show ?thesis
by simp
qed


Input:
lemma sH_g_ode_ivl: "t \<ge> 0 \<Longrightarrow> t \<in> T \<Longrightarrow> \<^bold>{P\<^bold>} (x\<acute>= (\<lambda>t. f) & G on (\<lambda>s. {0..t}) S @ 0) \<^bold>{Q\<^bold>} =
  (\<forall>s\<in>S. P s \<longrightarrow> (\<forall>t\<in>{0..t}. (\<forall>\<tau>\<in>{0..t}. G (\<phi> \<tau> s)) \<longrightarrow> Q (\<phi> t s)))"

Output:
apply(subst sH_g_ode_subset; clarsimp, (force)?)
using init_time interval_time mem_is_interval_1_I
by blast


Input:
lemma bdt_Some_Zero_iff [simp]:
  "(bdt t var = Some Zero) = (\<exists> p. t = Node Tip p Tip \<and> var p = 0)"

Output:
apply (induct t rule: bdt_fn.induct)
apply (auto split: option.splits) done


Input:
lemma extr_fake [simp]:
  assumes "T' \<subseteq> T" shows "extr T (fake T' U H) = extr T H"

Output:
proof (intro equalityI subsetI) fix At assume "At \<in> extr T (fake T' U H)" with assms have "At \<in> extr T (fake T U H)"
by auto thus "At \<in> extr T H"
by induct auto
qed auto


Input:
lemma tSplice_tLast[simp]:
  assumes tLen: "tLength t = tLength t'"
  assumes last: "envObs a (tLast t) = envObs a (tLast t')"
  shows "tLast (t \<^bsub>\<^esub>\<bowtie>\<^bsub>a\<^esub> t') = tLast t"

Output:
using tLen last unfolding envObs_def
apply (induct rule: trace_induct2)
apply (auto iff: sSplice_def fun_upd_idem_iff) done


Input:
lemma appCheckcast[simp]:
  "app\<^sub>i (Checkcast C,P,pc,mxs,T\<^sub>r,s) =
  (\<exists>T ST LT. s = (T#ST,LT) \<and> is_class P C \<and> is_refT T)"

Output: by (cases s, cases "fst s", simp add: app_def) (cases "hd (fst s)", auto)


Input: lemma KRP_subst [simp]: "(KRP v x x')(i::=t) = KRP (subst i t v) (subst i t x) (subst i t x')"

Output:
proof - obtain y::name where "atom y \<sharp> (v,x,x',t,i)"
by (metis obtain_fresh) thus ?thesis
by (auto simp: KRP.simps [of y])
qed


Input:
lemma ir_valid_Seq1:
  "ir_valid P (c1;; c2) c' Q \<Longrightarrow> ir_valid P c1 c' (\<lambda>t t'. \<exists>s s'. P s s' \<and> (c1,s) \<Rightarrow> t \<and> (c',s') \<Rightarrow> t' \<and> (\<exists>u. (c2,t) \<Rightarrow> u \<and> Q u t'))"

Output: by(auto simp: ir_valid_def)


Input:
lemma root_hash_T_simps [simp]:
  "root_hash_T rha (T\<^sub>m x) = T\<^sub>h (root_hash_F rha (root_hash_T rha) x)"

Output: by(simp add: root_hash_T_def F\<^sub>m.map_comp root_hash_F_def T\<^sub>h.map_id0)


Input:
lemma is_binqueue_add_Some:
  assumes "is_binqueue l xs"
  and     "is_bintree l t"
  and     "is_heap t"
  shows "is_binqueue l (add (Some t) xs)"

Output:
using assms
by (induct xs arbitrary: t) (simp_all add: is_bintree_list_merge is_heap_merge)


Input:
lemma it_path_SnocI:
  assumes "is \<in> it_paths t"
  assumes "i < length (children (tree_at t is))"
  shows "is @ [i] \<in> it_paths t"

Output:
using assms
by (induction t arbitrary: "is" i) (auto 4 4 elim!: it_paths_RNodeE intro: it_paths_intros)


Input:
lemma subst_eqvt'[eqvt]:
  fixes pi::"vrs prm"
  and   T::"ty"
  shows "pi\<bullet>(T[X \<mapsto> T']\<^sub>\<tau>) = (pi\<bullet>T)[(pi\<bullet>X) \<mapsto> (pi\<bullet>T')]\<^sub>\<tau>"

Output: by (nominal_induct T avoiding: X T' rule: ty.strong_induct) (perm_simp add: fresh_left)+


Input:
lemma avl_insert: "avl t \<Longrightarrow>
  avl(insert x t) \<and>
  height(insert x t) = height t + (if incr t (insert x t) then 1 else 0)"

Output:
apply(induction x t rule: insert.induct)
apply(auto split!: splits) done


Input:
lemma rgraph_and_network_impl_imp_rgraph_impl:
  assumes "RGraph c s t cf"
  assumes "Network_Impl c s t N"
  shows "RGraph_Impl c s t N cf"

Output:
using assms
by (rule Network_Impl.RGraph_Impl.intro)


Input:
lemma appInstanceof[simp]:
  "app\<^sub>i (Instanceof Ty,P,pc,mxs,T\<^sub>r,s) =
  (\<exists>T ST LT. s = (T#ST,LT) \<and> is_type P Ty \<and> is_refT T)"

Output: by (cases s, cases "fst s", simp add: app_def) (cases "hd (fst s)", auto)


Input: lemma continuous_on_s[continuous_intros]: "continuous_on T s"

Output:
unfolding s_def[abs_def]
using t_stop_nonneg
by (intro continuous_on_subset[where t=T and s = "{.. 0}\<union>({0 .. t_stop} \<union> {t_stop ..})"] continuous_on_If) (auto simp: p_continuous p_max_def antisym_conv[where x=0])


Input:
lemma AbstTerm_abst_dbtm:
     "AbstTerm (q_Var i) (ord_of n) \<lbrakk>quot_dbtm t\<rbrakk>e
                                    \<lbrakk>quot_dbtm (abst_dbtm i n t)\<rbrakk>e"

Output: by (induct t rule: dbtm.induct) (auto simp: AbstTerm_def SeqStTerm_def q_defs intro: BuildSeq2_exI BuildSeq2_combine)


Input:
lemma step_thread_eq_Some_activeD:
  "step_thread update_state s t = \<lfloor>(t', taxm\<sigma>')\<rfloor>
  \<Longrightarrow> t' = t \<and> t \<in> active_threads s"

Output:
unfolding step_thread_def
by(fastforce split: if_split_asm simp add: split_beta intro: active_threads.intros)


Input:
lemma (in Order) Iod_not_le_less:"\<lbrakk>T \<subseteq> carrier D; a \<in> T; b \<in> T;
       Torder (Iod D T)\<rbrakk> \<Longrightarrow> (\<not> a \<preceq>\<^bsub>(Iod D T)\<^esub> b) = b \<prec>\<^bsub>(Iod D T)\<^esub> a"

Output:
apply (subst Torder.not_le_less)
apply assumption+
apply (simp add:Iod_carrier)+ done


Input:
lemma ft_foldl_cunfold[code_unfold]:
  "List.foldl f \<sigma> (ft_\<alpha> t) = ft_foldl f \<sigma> t"

Output: apply (auto simp add: ft_defs FingerTree.foldl_correct) done


Input: lemma strip_comb_empty: "snd (strip_comb t) = [] \<Longrightarrow> fst (strip_comb t) = t"

Output: by (induction t rule: strip_comb_induct) (auto split: prod.splits)


Input: lemma vertex_subtreeI [intro]: "\<lbrakk> t \<in> V\<^bsub>T\<^esub>; v \<in> bag t \<rbrakk> \<Longrightarrow> t \<in> vertex_subtree v"

Output:
unfolding vertex_subtree_def
by blast


Input:
lemma ZObisT_transT2[consumes 3, case_names Match]:
assumes 0: "c \<approx>01T d" and "s \<approx> t" and "(d,t) \<rightarrow>t t'"
obtains s' where "(c,s) \<rightarrow>t s'" and "s' \<approx> t'"

Output:
using assms ZObisT_matchT_T_rev[OF 0] ZObisT_Sym unfolding matchT_T_def2
by blast


Input: lemma finpref_mono2: "s \<le> t \<Longrightarrow> finpref A s \<subseteq> finpref A t"

Output: by (unfold finpref_def) (auto dest: llist_le_trans)


Input:
lemma vector_derivative_part_circlepath01:
    "\<lbrakk>0 \<le> x; x \<le> 1\<rbrakk>
     \<Longrightarrow> vector_derivative (part_circlepath z r s t) (at x within {0..1}) =
          \<i> * r * (of_real t - of_real s) * exp(\<i> * linepath s t x)"

Output:
using has_vector_derivative_part_circlepath
by (auto simp: vector_derivative_at_within_ivl)


Input:
lemma Upd_beta: "Upd t l u \<rightarrow>\<^sub>\<beta> z \<Longrightarrow>
  (\<exists>t'. t \<rightarrow>\<^sub>\<beta> t' \<and> z = Upd t' l u)
  \<or>(\<exists>u' L. finite L
         \<and> (\<forall>s p. s \<notin> L \<and> p \<notin> L \<and> s \<noteq> p
             \<longrightarrow> (\<exists>t''. (u\<^bsup>[Fvar s, Fvar p]\<^esup>) \<rightarrow>\<^sub>\<beta> t'' \<and> u' = \<sigma>[s,p]t''))
         \<and> z = Upd t l u')
  \<or>(\<exists>f T. l \<in> dom f \<and> Obj f T = t \<and> z = Obj (f(l \<mapsto> u)) T)"

Output: by (erule beta_cases, auto)


Input:
lemma agent_abs_inv[dest]:
  "(u, v) \<in> agent_abs a t
    \<Longrightarrow> \<exists>t'. t' \<in> SPR.jkbpC \<and> spr_jview a t' = spr_jview a t
           \<and> u = tFirst t' \<and> v = tLast t'"

Output:
unfolding agent_abs_def
by blast


Input:
lemma has_lock_upd_locks_implies_has_lock:
  "\<lbrakk> has_lock (upd_locks l t Ls) t'; t \<noteq> t' \<rbrakk> \<Longrightarrow> has_lock l t'"

Output: by(induct l t Ls rule: upd_locks.induct)(auto intro: has_lock_upd_lock_implies_has_lock)


Input:
lemma homeomorphic_connectedness:
  assumes "s homeomorphic t"
  shows "connected s \<longleftrightarrow> connected t"

Output:
using assms unfolding homeomorphic_def homeomorphism_def
by (metis connected_continuous_image)


Input:
lemma (in Order) Iod_less:
  "\<lbrakk>T \<subseteq> carrier D; a \<in> T; b \<in> T\<rbrakk> \<Longrightarrow> (a \<prec>\<^bsub>Iod D T\<^esub> b) = (a \<prec> b)"

Output:
apply (simp add:oless_def)
apply (simp add:Iod_le) done


Input: lemma append_T_imp_tickFree:  "\<lbrakk>t @ s \<in> T P; s \<noteq> []\<rbrakk> \<Longrightarrow> tickFree t"

Output: by(frule is_processT2_TR[rule_format], simp add: front_tickFree_def tickFree_rev)


Input:
lemma ord_term_strict_canc_left:
  assumes "t \<oplus> v \<prec>\<^sub>t s \<oplus> v"
  shows "t \<prec> s"

Output:
proof (rule ccontr) assume "\<not> t \<prec> s" hence "s \<preceq> t"
by simp hence "s \<oplus> v \<preceq>\<^sub>t t \<oplus> v"
by (rule splus_mono_left) with assms show False
by simp
qed


Input:
lemma assumes v: "valid_tmap t"
      shows mremove_valid: "valid_tmap (mremove i t)"

Output:
proof (simp add: mremove_def) from v remove_sort show "sortedTree fst (remove fst (i, undefined) t)"
by fastforce
qed


Input:
lemma finite_Fvars_trm[simp]:
  fixes t :: trm
  shows "finite (Fvars t)"

Output: by (induct t rule: trm.induct) auto


Input: lemma span_scale: "x \<in> span S \<Longrightarrow> c *s x \<in> span S"

Output:
unfolding span_explicit
proof safe fix t r assume *: "finite t" "t \<subseteq> S" show "\<exists>t' r'. c *s (\<Sum>a\<in>t. r a *s a) = (\<Sum>a\<in>t'. r' a *s a) \<and> finite t' \<and> t' \<subseteq> S"
by (intro exI[of _ t] exI[of _ "\<lambda>a. c * r a"]) (auto simp: * scale_sum_right)
qed


Input:
lemma weight_le_stable:
  assumes "weight_le s t"
  shows "weight_le (s \<cdot> \<sigma>) (t \<cdot> \<sigma>)"

Output:
using assms weight_stable_le SCF_stable
by (auto simp: weight_le_def)


Input: theorem gt_or_eq_compat_App: "s' \<ge>\<^sub>t s \<Longrightarrow> t' \<ge>\<^sub>t t \<Longrightarrow> App s' t' \<ge>\<^sub>t App s t"

Output:
using gt_compat_fun gt_compat_arg
by blast


Input:
lemma cut_and_updateI[intro?]:
  "(\<And>ttas s' t x ta x' m'.
     \<lbrakk> s -\<triangleright>ttas\<rightarrow>* s'; ta_seq_consist P vs (llist_of (concat (map (\<lambda>(t, ta). \<lbrace>ta\<rbrace>\<^bsub>o\<^esub>) ttas)));
       thr s' t = \<lfloor>(x, no_wait_locks)\<rfloor>; t \<turnstile> (x, shr s') -ta\<rightarrow> (x', m'); actions_ok s' t ta \<rbrakk>
      \<Longrightarrow> \<exists>ta' x'' m''. t \<turnstile> (x, shr s') -ta'\<rightarrow> (x'', m'') \<and> actions_ok s' t ta' \<and>
                       ta_seq_consist P (mrw_values P vs (concat (map (\<lambda>(t, ta). \<lbrace>ta\<rbrace>\<^bsub>o\<^esub>) ttas))) (llist_of \<lbrace>ta'\<rbrace>\<^bsub>o\<^esub>) \<and>
                       eq_upto_seq_inconsist P \<lbrace>ta\<rbrace>\<^bsub>o\<^esub> \<lbrace>ta'\<rbrace>\<^bsub>o\<^esub> (mrw_values P vs (concat (map (\<lambda>(t, ta). \<lbrace>ta\<rbrace>\<^bsub>o\<^esub>) ttas))))
    \<Longrightarrow> cut_and_update s vs"

Output:
unfolding cut_and_update_def
by blast


Input:
lemma depth_max_heightE_right[elim!]:
"\<lbrakk>depth t\<^sub>2 a = max (height t\<^sub>1) (height t\<^sub>2);
  \<lbrakk>depth t\<^sub>2 a = height t\<^sub>2; height t\<^sub>2 \<ge> height t\<^sub>1\<rbrakk> \<Longrightarrow> P\<rbrakk> \<Longrightarrow>
 P"

Output: by (cut_tac t = t\<^sub>2 and a = a in depth_le_height) simp


Input:
lemma closure_subtopology_minimal:
  "S \<subseteq> T \<Longrightarrow> closedin (top_of_set X) T \<Longrightarrow> closure S \<inter> X \<subseteq> T"

Output:
apply (auto simp: closedin_closed)
using closure_minimal
by blast


Input:
lemma of_ocircline_opposite_ocircline [simp]:
  shows "of_ocircline (opposite_ocircline H) = of_ocircline H"

Output: by (transfer, transfer) (simp, erule exE, rule_tac x="-1" in exI, simp)


Input:
lemma list_of'_refs_of'_HOL:
  assumes "list_of' h r xs"
  shows "\<exists>rs. refs_of' h r rs"

Output:
proof - from assms obtain rs' where "refs_of h (Ref.get h r) rs'" unfolding list_of'_def
by (rule list_of_refs_of) thus ?thesis unfolding refs_of'_def'
by auto
qed


Input: lemma adj_with_w: "u \<rightarrow>\<^bsub>H\<^esub> w" "w \<rightarrow>\<^bsub>H\<^esub> u" "v \<rightarrow>\<^bsub>H\<^esub> w" "w \<rightarrow>\<^bsub>H\<^esub> v"

Output:
using in_arcs_H subdiv_ate
by (auto intro: H.dominatesI[rotated])


Input:
lemma remove_writes:
  "writes (remove_child_locs (the |h \<turnstile> get_parent child|\<^sub>r) |h \<turnstile> get_owner_document (cast child)|\<^sub>r)
(remove child) h h'"

Output: by(auto simp add: remove_def intro!: writes_bind_pure split: option.splits)


Input:
lemma parts_insert_Hash [simp]:
     "parts (insert (Hash X) H) = insert (Hash X) (parts H)"

Output:
apply (rule parts_insert_eq_I)
apply (erule parts.induct, auto) done


Input:
lemma sep_implI:
  assumes a: "\<And>h' h''. \<lbrakk> h \<oplus> h' = Some h''; P h' \<rbrakk> \<Longrightarrow> Q h''"
  shows "(P \<longrightarrow>\<^sup>* Q) h"

Output:
unfolding sep_impl_def
by (auto elim: a)


Input: lemma imp_neg_I: "H \<turnstile> A IMP B \<Longrightarrow> H \<turnstile> A IMP (neg B) \<Longrightarrow> H \<turnstile> neg A"

Output: by (metis dsjcnj [of B "neg A" "neg A"] dsjCont Bool dsj_commute MP_same)


Input: lemma All_D: "H \<turnstile> All i A \<Longrightarrow> H \<turnstile> A(i::=x)"

Output: by (metis Assume Ex_I NegNeg_D Neg_mono SyntaxN.Neg cut_same)


Input: lemma Disj_Neg_1: "H \<turnstile> A OR B \<Longrightarrow> H \<turnstile> Neg B \<Longrightarrow> H \<turnstile> A"

Output: by (metis Disj_I1 Disj_Semicong_1 Disj_commute Peirce)


Input: lemma ord_rec_non [simp]: "\<not> Ord x \<Longrightarrow> ord_rec T G H x = H x"

Output: by (metis Ord_0 ord_rec_def ord_recp_def the_equality)


Input:
lemma writes_pure [simp]:
  assumes "pure f h"
  shows "writes S f h h'"

Output:
using assms
apply(auto simp add: writes_def)[1]
by (metis bot.extremum iterate_M.simps(1) list.set(1) pure_returns_heap_eq return_returns_heap)


Input:
lemma Fake_parts_sing:
  "X \<in> synth (analz H) \<Longrightarrow> parts {X} \<subseteq> synth (analz H) \<union> parts H"

Output:
apply (rule subset_trans)
apply (erule_tac [2] Fake_parts_insert)
apply (rule parts_mono, blast) done


Input:
lemma HSem_restr_cong_below:
  assumes "\<rho> f|` (- domA h) \<sqsubseteq> \<rho>' f|` (- domA h)"
  shows "\<lbrace>h\<rbrace>\<rho> \<sqsubseteq> \<lbrace>h\<rbrace>\<rho>'"

Output: by (subst (1 2) HSem_restr[symmetric]) (rule monofun_cfun_arg[OF assms])


Input: lemma LstSeqP_SUCC: "H \<turnstile> LstSeqP r (SUCC d) y \<Longrightarrow> H \<turnstile> HPair d z IN r \<Longrightarrow> H \<turnstile> LstSeqP r d z"

Output: by (metis LstSeqP_Mem Mem_SUCC_I2 Refl)


Input:
lemma (in comm_group) IDirProd_eq_subgroup_mult:
  assumes "subgroup H G" "subgroup J G"
  shows "IDirProd G H J = H <#> J"

Output:
unfolding IDirProd_def
by (rule set_mult_eq_generate_subgroup[OF assms])


Input: lemma sc_hext_upd_arr: "\<lbrakk> rm_lookup a h = Some (Arr T si f e) \<rbrakk> \<Longrightarrow> h \<unlhd>sc rm_update a (Arr T si f' e') h"

Output: by(rule sc.hextI)(auto simp:fun_upd_apply sc_typeof_addr_def rm.lookup_correct rm.update_correct)


Input:
lemma Fake_parts_sing:
     "X \<in> synth (analz H) ==> parts{X} \<subseteq> synth (analz H) \<union> parts H"

Output:
apply (rule subset_trans)
apply (erule_tac [2] Fake_parts_insert)
apply (rule parts_mono, blast) done


Input:
lemma integral_linear:
  "f integrable_on S \<Longrightarrow> bounded_linear h \<Longrightarrow> integral S (h \<circ> f) = h (integral S f)"

Output: by (meson has_integral_iff has_integral_linear)


Input:
lemma heap_is_wellformed_one_disc_parent:
  "heap_is_wellformed h \<Longrightarrow> h \<turnstile> get_disconnected_nodes document_ptr \<rightarrow>\<^sub>r disc_nodes \<Longrightarrow>
  h \<turnstile> get_disconnected_nodes document_ptr' \<rightarrow>\<^sub>r disc_nodes' \<Longrightarrow> set disc_nodes \<inter> set disc_nodes' \<noteq> {}
  \<Longrightarrow> document_ptr = document_ptr'"

Output:
using CD.heap_is_wellformed_one_disc_parent local.heap_is_wellformed_def
by blast


Input:
lemma subdivision_compatible:
  assumes "subdivision (G, rev_G) (H, rev_H)" shows "compatible G H"

Output:
using assms
by induct (auto simp: compatible_def subdivision_step_def)


Input:
lemma bind_returns_heap_E3 [elim]:
  assumes "h \<turnstile> f \<bind> g \<rightarrow>\<^sub>h h'" and "h \<turnstile> f \<rightarrow>\<^sub>r x" and "pure f h"
  shows "h \<turnstile> g x \<rightarrow>\<^sub>h h'"

Output:
using assms pure_returns_heap_eq returns_result_eq
by (fastforce elim: bind_returns_heap_E)


Input:
lemma (in ring_hom_ring) inj_iff_trivial_ker:
  shows "inj_on h (carrier R) \<longleftrightarrow> a_kernel R S h = { \<zero> }"

Output:
using group_hom.inj_iff_trivial_ker[OF a_group_hom] a_kernel_def[of R S h]
by simp


Input:
lemma coprime_gcd:
  fixes h::"'a mod_ring poly"
  assumes "Rings.coprime (h-[:c1:]) (h-[:c2:])"
  shows "Rings.coprime (gcd f(h-[:c1:])) (gcd f (h-[:c2:]))"

Output:
using assms coprime_divisors
by blast


Input:
lemma append_child_heap_is_wellformed_preserved:
  assumes wellformed: "heap_is_wellformed h"
    and append_child: "h \<turnstile> append_child ptr node \<rightarrow>\<^sub>h h'"
    and known_ptrs: "known_ptrs h"
    and type_wf: "type_wf h"
  shows "heap_is_wellformed h'" and "type_wf h'" and "known_ptrs h'"

Output:
using assms
by(auto simp add: append_child_def intro: insert_before_child_preserves)


Input:
lemma relH_array:
  assumes "relH as h h'"
  assumes "addr_of_array r \<in> as"
  shows "Array.get h r = Array.get h' r"

Output:
using assms unfolding relH_def Array.get_def
by auto


Input: lemma confs_hext: "P,h \<turnstile> vs [:\<le>] Ts \<Longrightarrow> h \<unlhd> h' \<Longrightarrow> P,h' \<turnstile> vs [:\<le>] Ts"

Output: by (erule list_all2_mono, erule conf_hext, assumption)


Input:
lemma obtain_ideal_points:
  assumes "is_poincare_line H"
  obtains i1 i2 where "i1 \<noteq> i2" "ideal_points H = {i1, i2}"

Output:
using two_ideal_points[OF assms] card_eq_2_iff_doubleton[of "ideal_points H"]
by blast


Input:
lemma ptr_kinds_M_ptr_kinds [simp]:
  "h \<turnstile> a_ptr_kinds_M \<rightarrow>\<^sub>r xa \<longleftrightarrow> xa = sorted_list_of_set (fset (ptr_kinds h))"

Output: by(auto simp add: a_ptr_kinds_M_def)


Input:
lemma remove_heap_is_wellformed_preserved:
  assumes "heap_is_wellformed h" and "type_wf h" and "known_ptrs h"
  assumes "h \<turnstile> remove child \<rightarrow>\<^sub>h h'"
  shows "heap_is_wellformed h'"

Output:
using assms
by(auto simp add: remove_def elim!: bind_returns_heap_E2 intro: remove_child_heap_is_wellformed_preserved split: option.splits)


Input:
lemma known_ptrs_preserved:
  "object_ptr_kinds h = object_ptr_kinds h' \<Longrightarrow> a_known_ptrs h = a_known_ptrs h'"

Output: by(auto simp add: a_known_ptrs_def)


Input: lemma lconf_hext: "\<lbrakk> P,h \<turnstile> l (:\<le>) E; h \<unlhd> h' \<rbrakk> \<Longrightarrow> P,h' \<turnstile> l (:\<le>) E"

Output:
unfolding lconf_def
by(fast elim: conf_hext)


Input:
lemma (in finite_group) bigger_subgroup_is_group:
  assumes "subgroup H G" "card H \<ge> order G"
  shows "H = carrier G"

Output:
using subgroup.subset fin assms
by (metis card_seteq order_def)


Input:
lemma mod_star_TrueE': assumes "h\<Turnstile>P*True" obtains h' where
  "fst h' = fst h" and "snd h' \<subseteq> snd h" and "h'\<Turnstile>P"

Output:
using assms unfolding times_assn_def top_assn_def
apply (cases h)
apply (fastforce simp add: Abs_assn_inverse) done


Input:
lemma known_ptrs_new_ptr:
  "object_ptr_kinds h' = object_ptr_kinds h |\<union>| {|new_ptr|} \<Longrightarrow> known_ptr new_ptr \<Longrightarrow>
a_known_ptrs h \<Longrightarrow> a_known_ptrs h'"

Output: by(simp add: a_known_ptrs_def)


Input:
lemma parent_child_rel_parent:
  assumes "heap_is_wellformed h"
    and "h \<turnstile> get_parent child_node \<rightarrow>\<^sub>r Some parent"
  shows "(parent, cast child_node) \<in> parent_child_rel h"

Output:
using assms parent_child_rel_child get_parent_child_dual
by auto


Input: lemma invT_into : "h \<in> H \<Longrightarrow> invT h \<in> G"

Output:
using bijective bij_betw_imp_inj_on ImG the_inv_into_into[of T]
by force


Input: lemma parts_subset_iff [simp]: "(parts G \<subseteq> parts H) = (G \<subseteq> parts H)"

Output: by (metis parts_idem parts_increasing parts_mono subset_trans)


Input:
lemma sep_conj_impl:
  "\<lbrakk> (P ** Q) h; \<And>h. P h \<Longrightarrow> P' h; \<And>h. Q h \<Longrightarrow> Q' h \<rbrakk> \<Longrightarrow> (P' ** Q') h"

Output: by (erule sep_conjE, auto intro!: sep_conjI)


Input:
lemma sc_oconf_fupd_arr [intro?]:
  "\<lbrakk> P,h \<turnstile>sc v :\<le> T; P,h \<turnstile>sc (Arr T si f el) \<surd> \<rbrakk>
  \<Longrightarrow> P,h \<turnstile>sc (Arr T si f (rm_update i v el)) \<surd>"

Output:
unfolding sc_oconf_def
by(auto simp add: rm.update_correct)


Input: lemma get_heap_returns_heap [simp]: "(h \<turnstile> get_heap \<bind> (\<lambda>h'. f h') \<rightarrow>\<^sub>h h'') = (h \<turnstile> f h \<rightarrow>\<^sub>h h'')"

Output: by(simp add: get_heap_def returns_heap_def bind_def return_def execute_def)


Input:
lemma set_disconnected_nodes_get_tag_name:
  "\<forall>w \<in> set_disconnected_nodes_locs ptr. (h \<turnstile> w \<rightarrow>\<^sub>h h' \<longrightarrow> (\<forall>r \<in> get_tag_name_locs ptr'. r h h'))"

Output: by(auto simp add: CD.set_disconnected_nodes_locs_def CD.get_tag_name_locs_def all_args_def)


Input: lemma inf_on_circline: "on_circline H \<infinity>\<^sub>h \<longleftrightarrow> circline_A0 H"

Output: by (transfer, transfer, auto simp add: vec_cnj_def)


Input:
lemma analz_insert_Nonce [simp]:
     "analz (insert (Nonce N) H) = insert (Nonce N) (analz H)"

Output:
apply (rule analz_insert_eq_I)
apply (erule analz.induct, auto) done


Input:
lemma disc_opposite_ocircline [simp]:
  shows "disc (opposite_ocircline H) = disc_compl H"

Output:
using disc_compl_opposite_ocircline[of "opposite_ocircline H"]
by simp


Input:
lemma project_Stable_D:
     "F\<squnion>project h (reachable (extend h F\<squnion>G)) G \<in> Stable A
      ==> extend h F\<squnion>G \<in> Stable (extend_set h A)"

Output:
apply (unfold Stable_def)
apply (simp (no_asm_simp) add: project_Constrains_D) done


Input: lemma below_nice: "below[l,h] = (if [l,h] = \<bottom> then \<bottom> else [-\<infinity>,h])"

Output:
unfolding bot_ivl_def
by transfer (simp add: below_rep_def eq_ivl_empty)


Input:
lemma lemma1: "Key (invKey K) \<in> analz H \<Longrightarrow>
               analz (insert (Crypt K X) H) \<subseteq>
               insert (Crypt K X) (analz (insert X H))"

Output:
apply (rule subsetI)
apply (erule_tac x = x in analz.induct, auto) done


Input:
lemma bind_cong_2:
  assumes "pure f h" and "pure f h'"
    and "\<And>x. h \<turnstile> f \<rightarrow>\<^sub>r x = h' \<turnstile> f \<rightarrow>\<^sub>r x"
    and "\<And>x. h \<turnstile> f \<rightarrow>\<^sub>r x \<Longrightarrow> h \<turnstile> g x \<rightarrow>\<^sub>r y = h' \<turnstile> g x \<rightarrow>\<^sub>r y'"
  shows "h \<turnstile> f \<bind> g \<rightarrow>\<^sub>r y = h' \<turnstile> f \<bind> g \<rightarrow>\<^sub>r y'"

Output:
using assms
by(auto intro!: bind_pure_returns_result_I elim!: bind_returns_result_E2)


Input:
lemma known_ptrs_subset:
  "object_ptr_kinds h' |\<subseteq>| object_ptr_kinds h \<Longrightarrow> a_known_ptrs h \<Longrightarrow> a_known_ptrs h'"

Output: by(simp add: a_known_ptrs_def less_eq_fset.rep_eq subsetD)


Input:
lemma get_disconnected_nodes_ptr_in_heap:
  "h \<turnstile> ok (get_disconnected_nodes document_ptr) \<Longrightarrow> document_ptr |\<in>| document_ptr_kinds h"

Output:
unfolding get_disconnected_nodes_impl[unfolded a_get_disconnected_nodes_def]
by (simp add: DocumentMonad.get_M_ptr_in_heap)


Input:
lemma bind_case_cong [fundef_cong]:
  assumes "x = x'" and "\<And>a. x = Some a \<Longrightarrow> f a h = f' a h"
  shows "(case x of Some a \<Rightarrow> f a | None \<Rightarrow> g) h = (case x' of Some a \<Rightarrow> f' a | None \<Rightarrow> g) h"

Output: by (insert assms, simp add: option.case_eq_if)


Input:
lemma is_empty_op_correct[refine_vcg]:
      "heap_invar h \<Longrightarrow> is_empty_op h \<le> SPEC (\<lambda>r. r\<longleftrightarrow>\<alpha> h = {#})"

Output:
unfolding is_empty_op_def
apply refine_vcg
by auto


Input: lemma snth_sconst: "(\<forall>i. s !! i = h) = (s = sconst h)"

Output: by (metis funpow_code_def id_funpow sdrop_simps(1) sdrop_siterate siterate.simps(1) smap_alt smap_sconst snth.simps(1) stream.map_id)


Input:
lemma adopt_node_child_in_heap:
  assumes "h \<turnstile> ok (adopt_node document_ptr child)"
  shows "child |\<in>| node_ptr_kinds h"

Output:
using assms
apply(auto simp add: adopt_node_def elim!: bind_is_OK_E)[1]
using get_owner_document_pure get_parent_ptr_in_heap pure_returns_heap_eq
by fast


Input:
lemma assigned_nodes_slot_is_slot:
  assumes "h \<turnstile> ok (assigned_nodes slot)"
  shows "h \<turnstile> get_tag_name slot \<rightarrow>\<^sub>r ''slot''"

Output:
using assms
by(auto simp add: assigned_nodes_def elim!: bind_is_OK_E split: if_splits)


Input:
lemma spanning_tree_imp_tree[dest]:
  assumes "spanning_tree H G"
  shows "tree H"

Output:
using assms
by (simp add: spanning_tree_def)


Input:
lemma set_child_nodes_get_disconnected_nodes:
  "\<forall>w \<in> a_set_child_nodes_locs ptr. (h \<turnstile> w \<rightarrow>\<^sub>h h' \<longrightarrow> (\<forall>r \<in> a_get_disconnected_nodes_locs ptr'. r h h'))"

Output: by(auto simp add: a_set_child_nodes_locs_def a_get_disconnected_nodes_locs_def all_args_def)


Input:
lemma hm_decrease_key_op_refine:
      "\<lbrakk>(hm,h)\<in>hmr_rel; (hm,m)\<in>heapmap_rel; m k = Some v'\<rbrakk>
        \<Longrightarrow> hm_decrease_key_op k v hm \<le>\<Down>hmr_rel (h.decrease_key_op (hm_index hm k) v h)"

Output:
unfolding hm_decrease_key_op_def h.decrease_key_op_def
apply (refine_rcg index_op_inline_refine) unfolding hmr_rel_def heapmap_rel_def in_br_conv
apply (clarsimp_all) done


Input:
lemma bind_is_OK_E [elim]:
  assumes "h \<turnstile> ok (f \<bind> g)"
  obtains x h' where "h \<turnstile> f \<rightarrow>\<^sub>r x" and "h \<turnstile> f \<rightarrow>\<^sub>h h'" and "h' \<turnstile> ok (g x)"

Output:
using assms
by(auto simp add: bind_def returns_result_def returns_heap_def is_OK_def execute_def split: sum.splits)


Input:
lemma (in cring) subcringI':
  assumes "subring H R"
  shows "subcring H R"

Output:
using subcringI[OF assms] subringE(1)[OF assms] m_comm
by auto


Input:
lemma shadow_root_host_dual:
  assumes "h \<turnstile> get_host shadow_root_ptr \<rightarrow>\<^sub>r host"
  shows "h \<turnstile> get_shadow_root host \<rightarrow>\<^sub>r Some shadow_root_ptr"

Output:
using assms
by(auto simp add: get_host_def dest: filter_M_holds_for_result elim!: bind_returns_result_E2 intro!: bind_pure_I split: list.splits)


Input:
lemma element_ptr_kinds_M_eq:
  assumes "|h \<turnstile> node_ptr_kinds_M|\<^sub>r = |h' \<turnstile> node_ptr_kinds_M|\<^sub>r"
  shows "|h \<turnstile> element_ptr_kinds_M|\<^sub>r = |h' \<turnstile> element_ptr_kinds_M|\<^sub>r"

Output:
using assms
by(auto simp add: element_ptr_kinds_M_defs node_ptr_kinds_M_defs element_ptr_kinds_def)


Input:
lemma heap_clone_typeof_addrD:
  assumes "heap_clone P h a h' \<lfloor>(obs, a')\<rfloor>"
  and "hconf h"
  shows "NewHeapElem a'' x \<in> set obs \<Longrightarrow> a'' = a' \<and> typeof_addr h' a' = Some x"

Output:
using assms
by(fastforce elim!: heap_clone.cases dest: allocate_SomeD hext_heap_copies heap_copies_not_New typeof_addr_is_type elim: hext_objD hext_arrD)


Input: lemma Contrapos2: "H \<turnstile> (Neg B) IMP (Neg A) \<Longrightarrow> H \<turnstile> A IMP B"

Output: by (metis Bool MP_same boolean_axioms.DisjConj boolean_axioms.Ident)


Input: lemma parts_UN_subset2: "parts(\<Union>x\<in>A. H x) \<subseteq> (\<Union>x\<in>A. parts(H x))"

Output:
apply (rule subsetI)
apply (erule parts.induct, blast+) done


Input: lemma delete_type: "t \<in> B h \<Longrightarrow> delete x t \<in> B h \<union> B(h-1)"

Output:
unfolding delete_def
by (cases h) (simp, metis del_type(1) tree_type Suc_eq_plus1 diff_Suc_1)


Input:
lemma moebius_circline_comp_inv_left [simp]:
  shows "moebius_circline (moebius_inv M) (moebius_circline M H) = H"

Output: by (subst moebius_circline_comp[symmetric], simp)


Input: lemma Disjoint_commute_D: "insert (Disjoint t u) H \<turnstile> A \<Longrightarrow> insert (Disjoint u t) H \<turnstile> A"

Output: by (metis Assume Disjoint_commute_I cut_same insert_commute thin1)


Input:
lemma parts_insert_Number [simp]:
     "parts (insert (Number N) H) = insert (Number N) (parts H)"

Output:
apply (rule parts_insert_eq_I)
apply (erule parts.induct, auto) done


Input: lemma bij_project_act: "bij h ==> bij (project_act (%(x,u::'c). h x))"

Output:
apply (frule bij_imp_bij_inv [THEN bij_extend_act])
apply (simp add: bij_extend_act_eq_project_act bij_imp_bij_inv inv_inv_eq) done


Input:
lemma (in Group) rcsTr2:"\<lbrakk>G \<guillemotright> H; a \<in> carrier G; b \<in> H \<bullet> (\<rho> a)\<rbrakk> \<Longrightarrow>
                          b \<cdot> a \<in> H"

Output:
apply (frule i_closed[of "a"], frule_tac rcs_subset_elem[of "H" "\<rho> a" "b"], assumption+, frule rcs_eqTr1[of "H" "b" "\<rho> a"], assumption+)
apply (simp add:iop_i_i) done


Input:
lemma deterministic_heap_ops_writeD:
  "\<lbrakk> deterministic_heap_ops; heap_write h ad al v h'; heap_write h ad al v h'' \<rbrakk> \<Longrightarrow> h' = h''"

Output:
unfolding deterministic_heap_ops_def
by blast


Input: lemma all_E: "insert (A(i::=x)) H \<turnstile> B \<Longrightarrow> insert (all i A) H \<turnstile> B"

Output: by (metis exi_I negneg_D neg_mono neg)


Input:
lemma (in AbGroup) abSubgroup_inner_dirsum_el_decomp_set :
  "\<lbrakk> \<forall>H \<in> set Hs. Subgroup H; add_independentS Hs; x \<in> (\<Oplus>H\<leftarrow>Hs. H) \<rbrakk>
    \<Longrightarrow> set (\<Oplus>Hs\<leftarrow>x) \<subseteq> G"

Output:
using AbGroup.intro AbGroup_inner_dirsum_el_decompI[of Hs x] set_listset_el_subset[of "(\<Oplus>Hs\<leftarrow>x)" Hs G]
by fast


Input:
lemma projecting_Always:
     "projecting (%G. reachable (extend h F\<squnion>G)) h F
                 (Always (extend_set h A)) (Always A)"

Output:
apply (unfold projecting_def)
apply (blast intro: project_Always_I) done


Input:
lemma dvdmE:
  assumes fg: "f dvdm g"
    and main: "\<And>h. g =m f * h \<Longrightarrow> Mp h = h \<Longrightarrow> thesis"
  shows "thesis"

Output:
proof- from fg obtain h where "g =m f * h"
by (auto simp: dvdm_def) then have "g =m f * Mp h"
by auto from main[OF this] show thesis
by auto
qed


Input: lemma (in Group) homom4_2:"\<lbrakk>G \<triangleright> N; G \<guillemotright> H\<rbrakk> \<Longrightarrow> Group ((Gp G H) / (H \<inter> N))"

Output: by (frule Group_Gp[of "H"], frule inter_Gp_nsg[of "N" "H"], assumption, rule Group.Group_Qg, assumption+)


Input: lemma synth_analz_mono: "G\<subseteq>H \<Longrightarrow> synth (analz(G)) \<subseteq> synth (analz(H))"

Output: by (iprover intro: synth_mono analz_mono)


Input: lemma get_heap_returns_result [simp]: "(h \<turnstile> get_heap \<bind> (\<lambda>h'. f h') \<rightarrow>\<^sub>r x) = (h \<turnstile> f h \<rightarrow>\<^sub>r x)"

Output: by(simp add: get_heap_def returns_result_def bind_def return_def execute_def)


Input:
lemma set_mode_get_shadow_root:
  "\<forall>w \<in> set_mode_locs ptr. (h \<turnstile> w \<rightarrow>\<^sub>h h' \<longrightarrow> (\<forall>r \<in> get_shadow_root_locs ptr'. r h h'))"

Output: by(auto simp add: set_mode_locs_def get_shadow_root_locs_def all_args_def)


Input:
lemma empty_collapse_empty:
  assumes H: "emptyseq s" shows "emptyseq (\<natural> s)"

Output:
using H
by (simp add: emptyseq_collapse_eq)


Input:
lemma Mem_SUCC_E:
  assumes "insert (u IN t) H \<turnstile> C" "insert (u EQ t) H \<turnstile> C" shows "insert (u IN SUCC t) H \<turnstile> C"

Output: by (metis assms Mem_Eats_E SUCC_def)


Input: lemma parts_analz [simp]: "parts (analz H) = parts H"

Output:
apply (rule equalityI)
apply (metis analz_subset_parts parts_subset_iff)
apply (metis analz_increasing parts_mono) done


Input:
lemma confT_hext [intro?, trans]:
  "\<lbrakk> P,h \<turnstile> x :\<le>\<^sub>\<top> T; h \<unlhd> h' \<rbrakk> \<Longrightarrow> P,h' \<turnstile> x :\<le>\<^sub>\<top> T"

Output: by (cases T) (blast intro: conf_hext)+


Input:
lemma writes_union_left_I:
  assumes "writes S f h h'"
  shows "writes (S \<union> S') f h h'"

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


Input:
lemma subgroup_transitive [trans]:
  assumes "subgroup K H composition unit"
    and "subgroup H G composition unit"
  shows "subgroup K G composition unit"

Output:
proof - interpret K: subgroup K H composition unit
by fact interpret H: subgroup H G composition unit
by fact show ?thesis
by unfold_locales auto
qed


Input:
lemma (in group) generate_minimal:
  assumes "H \<subseteq> carrier G" shows "generate G H = \<Inter> { H'. subgroup H' G \<and> H \<subseteq> H' }"

Output:
using generate_subgroup_incl generate_is_subgroup[OF assms] incl[of _ H]
by blast


Input:
lemma heap_is_wellformed_one_disc_parent: "heap_is_wellformed h \<Longrightarrow>
h \<turnstile> get_disconnected_nodes document_ptr \<rightarrow>\<^sub>r disc_nodes \<Longrightarrow>
h \<turnstile> get_disconnected_nodes document_ptr' \<rightarrow>\<^sub>r disc_nodes' \<Longrightarrow> set disc_nodes \<inter> set disc_nodes' \<noteq> {} \<Longrightarrow>
document_ptr = document_ptr'"

Output:
using CD.heap_is_wellformed_one_disc_parent local.heap_is_wellformed_def
by blast


Input:
lemma bind_returns_result_E:
  assumes "h \<turnstile> f \<bind> g \<rightarrow>\<^sub>r y"
  obtains x h' where "h \<turnstile> f \<rightarrow>\<^sub>r x" and "h \<turnstile> f \<rightarrow>\<^sub>h h'" and "h' \<turnstile> g x \<rightarrow>\<^sub>r y"

Output:
using assms
by(auto simp add: bind_def returns_result_def returns_heap_def execute_def split: sum.splits)


Input:
lemma interchange:
    assumes "seq h g" and "seq h' g'"
    shows "(h \<otimes> h') \<cdot> (g \<otimes> g') = h \<cdot> g \<otimes> h' \<cdot> g'"

Output:
using assms T.preserves_comp [of "(h, h')" "(g, g')"]
by simp


Input:
lemma induced_subgraphI[intro]:
  assumes "subgraph H G"
  assumes "arcs H = {e \<in> arcs G. tail G e \<in> verts H \<and> head G e \<in> verts H}"
  shows "induced_subgraph H G"

Output:
using assms unfolding induced_subgraph_def
by safe


Input:
lemma (in aGroup) asubg_pOp_closed:"\<lbrakk>asubGroup A H; x \<in> H; y \<in> H\<rbrakk>
                                   \<Longrightarrow> pop A x y \<in> H"

Output:
apply (simp add:asubGroup_def)
apply (cut_tac b_ag_group)
apply (frule Group.sg_mult_closed [of "b_ag A" "H" "x" "y"], assumption+)
apply (simp only:agop_gop) done


Input:
lemma parts_insert_Hash [simp]:
     "parts (insert (Hash X) H) = insert (Hash X) (parts H)"

Output:
apply (rule parts_insert_eq_I)
apply (erule parts.induct, auto) done


Input:
lemma effect_refE [effect_elims]:
  assumes "effect (ref v) h h' r"
  obtains "get h' r = v" and "present h' r" and "\<not> present h r"

Output:
using assms
by (rule effectE) (simp add: execute_simps)


Input:
lemma zero_reducibility_implies_lt_divisibility:
  assumes "(red F)\<^sup>*\<^sup>* f 0" and "f \<noteq> 0"
  obtains h where "h \<in> F" and "h \<noteq> 0" and "lt h adds\<^sub>t lt f"

Output:
using zero_reducibility_implies_lt_divisibility'[OF assms]
by auto


Input:
lemma analz_insert_Crypt:
     "Key (invKey K) \<notin> analz H
      ==> analz (insert (Crypt K X) H) = insert (Crypt K X) (analz H)"

Output:
apply (rule analz_insert_eq_I)
apply (erule analz.induct, auto) done


Input:
lemma heap_copies_allocated_same:
  assumes "heap_copies a a' al h obs h'"
  shows "allocated h' = allocated h"

Output:
using assms
by(induct)(auto simp add: heap_copy_loc_allocated_same)


Input:
lemma intersects_x_axis_intersects_y_axis [simp]:
  shows "intersects_x_axis (moebius_circline (moebius_rotation (pi/2)) H) \<longleftrightarrow> intersects_y_axis H"

Output:
unfolding moebius_rotation_def moebius_similarity_def
by simp (transfer, transfer, auto simp add: mat_adj_def mat_cnj_def)


Input:
lemma parts_insert_Agent [simp]:
     "parts (insert (Agent agt) H) = insert (Agent agt) (parts H)"

Output:
apply (rule parts_insert_eq_I)
apply (erule parts.induct, auto) done


Input:
lemma (in group) rcos_assoc_lcos:
  "\<lbrakk>H \<subseteq> carrier G; K \<subseteq> carrier G; x \<in> carrier G\<rbrakk> \<Longrightarrow>
   (H #> x) <#> K = H <#> (x <# K)"

Output:
using set_mult_assoc[of H "{x}" K]
by (simp add: l_coset_eq_set_mult r_coset_eq_set_mult)


Input:
lemma pure_eq_iff:
  "(\<forall>h' x. h \<turnstile> f \<rightarrow>\<^sub>r x \<longrightarrow> h \<turnstile> f \<rightarrow>\<^sub>h h' \<longrightarrow> h = h') \<longleftrightarrow> pure f h"

Output: by(auto simp add: pure_def)


Input:
lemma addr_loc_type_hext_mono:
  "\<lbrakk> P,h \<turnstile> a@al : T; h \<unlhd> h' \<rbrakk> \<Longrightarrow> P,h' \<turnstile> a@al : T"

Output: by(force elim!: addr_loc_type.cases intro: addr_loc_type.intros elim: typeof_addr_hext_mono dest: hext_arrD)


Input:
lemma projecting_Stable:
     "projecting (%G. reachable (extend h F\<squnion>G)) h F
                 (Stable (extend_set h A)) (Stable A)"

Output:
apply (unfold Stable_def)
apply (rule projecting_Constrains) done


Input:
lemma (in heap_base) start_heap_data_code:
  "start_heap_data =
   (let
     (h, ads, b) = foldl
        (\<lambda>(h, ads, b) C.
           if b then
             let HA = allocate h (Class_type C)
             in if HA = {} then (h, ads, False)
                else let (h', a'') = pick_addr HA in (h', a'' # ads, True)
           else (h, ads, False))
        (empty_heap, [], True)
        initialization_list
    in (h, rev ads, b))"

Output:
unfolding start_heap_data_def create_initial_object_def pick_addr_def
by(rule rev_induct)(simp_all add: split_beta)


Input:
lemma well_base\<^sub>h_mono_base:
  assumes
    well\<^sub>h: "well_base\<^sub>h base M" and
    two: "2 \<le> base" and
    bases: "base \<le> base'"
  shows "well_base\<^sub>h base' M"

Output:
using two well\<^sub>h
by (induct rule: well_base\<^sub>h.induct) (meson two bases less_le_trans order_trans well_base\<^sub>h.intros well_base.simps)


Input: lemma upred_lattice_Monotonic [simp]: "Mono\<^bsub>\<P>\<^esub> H = Monotonic H"

Output:
using upred_lattice.weak_partial_order_axioms
by (auto simp add: isotone_def mono_def)


Input:
lemma merkle_interfaceI [locale_witness]:
  assumes "merge_on UNIV h bo m"
  shows "merkle_interface h bo m"

Output:
using assms unfolding merkle_interface_aux
by auto


Input: lemma sc_oconf_new: "\<lbrakk> P,h \<turnstile>sc obj \<surd>; h a = None \<rbrakk> \<Longrightarrow> P,h(a \<mapsto> arrobj) \<turnstile>sc obj \<surd>"

Output: by(erule sc_oconf_hext)(rule sc_hext_new)


Input: lemma Mem_Eats_I1: "H \<turnstile> u IN t \<Longrightarrow> H \<turnstile> u IN Eats t z"

Output: by (metis Disj_I1 Iff_MP2_same Mem_Eats_Iff)


Input:
lemma mat_assoc_test:
  fixes A B C D :: "complex mat"
  assumes "A \<in> carrier_mat n n" "B \<in> carrier_mat n n" "C \<in> carrier_mat n n" "D \<in> carrier_mat n n"
  shows
    "(A * B) * (C * D) = A * B * C * D"
    "adjoint (A * adjoint B) * C = B * (adjoint A * C)"
    "A * 1\<^sub>m n * 1\<^sub>m n * B * 1\<^sub>m n = A * B"
    "(A - B) + (B - C) = A + (-B) + B + (-C)"
    "A + (B - C) = A + B - C"
    "A - (B + C + D) = A - B - C - D"
    "(A + B) * (B + C) = A * B + B * B + A * C + B * C"
    "A - B = A + (-1) \<cdot>\<^sub>m B"
    "A * (B - C) * D = A * B * D - A * C * D"
    "trace (A * B * C) = trace (B * C * A)"
    "trace (A * B * C * D) = trace (C * D * A * B)"
    "trace (A + B * C) = trace A + trace (C * B)"
    "A + B = B + A"
    "A + B + C = C + B + A"
    "A + B + (C + D) = A + C + (B + D)"

Output:
using assms
by (mat_assoc n)+


Input:
lemma (in abelian_group) four_elem_comm:
  assumes "a \<in> carrier G" and "b \<in> carrier G" and "c \<in> carrier G" and "d \<in> carrier G"
  shows "a \<ominus> c \<oplus> b \<ominus> d = a \<oplus> b \<ominus> c \<ominus> d"

Output:
using assms a_assoc a_comm
by (simp add: a_minus_def)


Input: lemma sum_eqpoll_cong: "\<lbrakk>A \<approx> C; B \<approx> D\<rbrakk> \<Longrightarrow> A <+> B \<approx> C <+> D"

Output: by (meson eqpoll_imp_lepoll eqpoll_sym lepoll_antisym sum_lepoll_mono)


Input:
lemma ang_not_lg_None:
  assumes "QCong la" and
    "QCong lc" and
    "QCongA a" and
    "la A B" and
    "lc C B" and
    "a A B C"
  shows "\<not> QCongNull la \<and> \<not> QCongNull lc"

Output: by (metis ang_not_None_lg ang_sym assms(1) assms(2) assms(3) assms(4) assms(5) assms(6))


Input:
lemma Lt_cases:
  assumes "A B Lt C D \<or> B A Lt C D \<or> A B Lt D C \<or> B A Lt D C"
  shows "A B Lt C D"

Output:
using assms lt_comm lt_left_comm
by blast


Input:
lemma ereal_mult_less_right:
  fixes a b c :: ereal
  assumes "b * a < c * a"
    and "0 < a"
    and "a < \<infinity>"
  shows "b < c"

Output:
using assms
by (cases rule: ereal3_cases[of a b c]) (auto split: if_split_asm simp: zero_less_mult_iff zero_le_mult_iff)


Input:
lemma le_cases:
  shows "A B Le C D \<or> C D Le A B"

Output: by (metis (full_types) cong_reflexivity l5_5_2 l5_6 not_bet_distincts segment_construction_2)


Input:
lemma not_cong_is_ang1:
  assumes "\<not> A B C CongA A' B' C'" and
    "A B C Ang a"
  shows "\<not> A' B' C' Ang a"

Output:
using assms(1) assms(2) is_ang_conga
by blast


Input: lemma eint_add_left_cancel_le: "a + b \<le> a + c \<longleftrightarrow> a = (\<infinity>::eint) \<or> b \<le> c"

Output:
unfolding plus_eint_def
by (simp split: eint.split)


Input:
lemma is_anga_distinct:
  assumes "A B C AngAcute a"
  shows "A \<noteq> B \<and> C \<noteq> B"

Output:
using assms is_ang_distinct is_anga_to_is_ang
by blast


Input:
lemma le_extend_mult: "\<lbrakk>0 < c; a \<le> b\<rbrakk> \<Longrightarrow> a \<le> b * c"
  for c :: nat

Output: by (metis divisors_zero dvd_triv_left leI less_le_trans nat_dvd_not_less zero_less_iff_neq_zero)


Input:
lemma prod_hrp_comp:
    "hrp_comp (A *\<^sub>a B) (C \<times>\<^sub>r D) = hrp_comp A C *\<^sub>a hrp_comp B D"

Output:
unfolding hrp_comp_def hfprod_def
by simp


Input:
lemma A7':
    assumes "B a p c" and "B b q c"
    shows "\<exists>x. B p x b \<and> B q x a"

Output:
proof - from A7 and \<open>B a p c\<close> and \<open>B b q c\<close> show ?thesis
by blast
qed


Input:
lemma the_apartment_iso_chamber_map:
  "\<lbrakk> A\<in>\<A>; B\<in>\<A>; chamber C; C\<in>A\<inter>B; chamber D; D\<in>A \<rbrakk> \<Longrightarrow>
    chamber (the_apartment_iso A B ` D)"

Output:
using chamber_in_apartment[of A] apartment_chamber the_apartment_iso_apartment_chamber_map
by auto


Input:
lemma widen_trans [trans] :
  assumes a_b: "a \<preceq> b"
  shows "\<And> c. b \<preceq> c \<Longrightarrow> a \<preceq> c"

Output: by (insert a_b, rule rtrancl_trans)


Input:
lemma lea__nlta:
  assumes "A B C LeA D E F"
  shows "\<not> D E F LtA A B C"

Output: by (meson Tarski_neutral_dimensionless.lea_asym Tarski_neutral_dimensionless.not_lta_and_conga Tarski_neutral_dimensionless_axioms assms lta__lea)


Input: lemma diff_add_eq_ereal: fixes a b c :: ereal shows "a - b + c = a + c - b"

Output: by(cases a b c rule: ereal3_cases) simp_all


Input:
lemma project_constrains_mono:
     "[| D \<subseteq> C; project h C F \<in> A co B |] ==> project h D F \<in> A co B"

Output:
apply (auto simp add: constrains_def)
apply (drule project_act_mono, blast) done


Input:
lemma degree2_coeffs: "degree p = 2 \<Longrightarrow>
  \<exists> a b c. p = [: c, b, a :] \<and> a \<noteq> 0"

Output: by (metis Suc_1 Suc_neq_Zero degree1_coeffs degree_pCons_eq_if nat.inject pCons_cases)


Input:
lemma coplanar_perm_5:
  assumes "Coplanar A B C D"
  shows "Coplanar A D C B"

Output:
proof - obtain X where P1: "(Col A B X \<and> Col C D X) \<or> (Col A C X \<and> Col B D X) \<or> (Col A D X \<and> Col B C X)"
using Coplanar_def assms
by blast then show ?thesis
using Coplanar_def col_permutation_4
by blast
qed


Input:
lemma ns_s_mul_ext_union_multiset_l:
  assumes "(A, B) \<in> ns_mul_ext ns s"
    and "C \<noteq> {#}"
    and "\<forall>d. d \<in># D \<longrightarrow> (\<exists>c. c \<in># C \<and> (c,d) \<in> s)"
  shows "(A + C, B + D) \<in> s_mul_ext ns s"

Output:
using assms unfolding ns_mul_ext_def s_mul_ext_def
by (auto intro!: converseI mult2_alt_ns_s_add mult2_alt_sI[of _ "{#}" _ _ "{#}"])


Input:
lemma mapping_single_eq_iff [simp]:
  "Poly_Mapping.single a b = Poly_Mapping.single c d \<longleftrightarrow> b = 0 \<and> d = 0 \<or> a = c \<and> b = d"

Output: by transfer (unfold fun_eq_iff when_def, metis)


Input: lemma simple_distinct_map': "r \<in> simple_rotations \<Longrightarrow> distinct[a,b,c,d] \<Longrightarrow> (\<forall> e \<in> {a,b,c}. r f \<noteq> e) \<Longrightarrow> r f = d"

Output:
using complex_rotations.simp distinct_map'
by simp


Input:
lemma out_None_ang:
  assumes "QCongA a" and
    "a A B C" and
    "B Out A C"
  shows "QCongANull a"

Output: by (metis QCongANull_def QCongAnNull_def assms(1) assms(2) assms(3) not_None_ang_def_equiv)


Input: lemma flowsto_congI: "flowsto A B C D = c1_on_open_euclidean.flowsto g f' Y A B C D"

Output:
using flowsto_congI1[of A B C D] flowsto_congI2[of A B C D]
by auto


Input:
lemma neg_minus_divideC_le_eq [field_simps]:
  "- (b /\<^sub>C c) \<le> a \<longleftrightarrow> c *\<^sub>C a \<le> - b" if "c < 0"
for a b :: "'a :: ordered_complex_vector"

Output:
using that pos_minus_divideC_le_eq [of "- c" "- b" a]
by (metis Complex_Vector_Spaces0.neg_divideC_le_eq complex_vector.scale_minus_right)


Input:
lemma mat_leqb_eqc_split_simplex_correct1:
  assumes "dim_vec b = dim_row A"
  assumes "simplex (mat_leqb_eqc A b c) = Sat X"
  assumes "(x,y) = split_i_j_x (dim_col A) l X"
  shows "[A *\<^sub>v x]\<le>b"

Output:
using mat_leqb_eqc_split_correct1[of b A c X x y] assms(1) assms(2) assms(3) simplex(3)
by blast


Input: lemma inter_mset_empty_distrib_right: "A \<inter># (B + C) = {#} \<longleftrightarrow> A \<inter># B = {#} \<and> A \<inter># C = {#}"

Output: by (meson disjunct_not_in union_iff)


Input:
lemma per_cong_mid:
  assumes "B \<noteq> C" and
    "Bet A B C" and
    "Cong A H C H" and
    "Per H B C"
  shows "B Midpoint A C"

Output:
using assms(1) assms(2) assms(3) assms(4) per_cong_mid_R1 per_cong_mid_R2
by blast


Input:
lemma anga_not_lg_None:
  assumes (*"QCong la" and
  "QCong lc" and*)
    "QCongAAcute a" and
    "la A B" and
    "lc C B" and
    "a A B C"
  shows  "\<not> QCongNull la \<and> \<not> QCongNull lc"

Output: by (metis QCongNull_def anga_not_None_lg anga_sym assms(1) assms(2) assms(3) assms(4))


Input:
lemma coplanar_perm_3:
  assumes "Coplanar A B C D"
  shows "Coplanar A C D B"

Output:
proof - obtain X where P1: "(Col A B X \<and> Col C D X) \<or> (Col A C X \<and> Col B D X) \<or> (Col A D X \<and> Col B C X)"
using Coplanar_def assms
by blast then show ?thesis
using Coplanar_def col_permutation_4
by blast
qed


Input:
lemma
  fixes a b c d x y z :: "'a::linordered_field"
  shows "a*(b*c)/(y*z) = d*(b)*(x*a)/z"

Output: oops \<comment> \<open>FIXME: need simproc to cover this case\<close>


Input:
lemma perp_in_left_comm:
  assumes "X PerpAt A B C D"
  shows "X PerpAt B A C D"

Output: by (metis Col_cases PerpAt_def assms)


Input:
lemma neg_divideR_le_eq [field_simps]:
  "b /\<^sub>R c \<le> a \<longleftrightarrow> c *\<^sub>R a \<le> b" if "c < 0"
    for a b :: "'a :: ordered_real_vector"

Output:
using that pos_divideR_le_eq [of "- c" "- b" a]
by simp


Input:
lemma comp_assoc_assoc' [simp]:
    assumes "ide a" and "ide b" and "ide c"
    shows "\<a>[a, b, c] \<cdot> \<a>\<^sup>-\<^sup>1[a, b, c] = a \<otimes> (b \<otimes> c)"
    and "\<a>\<^sup>-\<^sup>1[a, b, c] \<cdot> \<a>[a, b, c] = (a \<otimes> b) \<otimes> c"

Output:
using assms assoc_inv comp_arr_inv comp_inv_arr
by auto


Input:
lemma shiftr_shiftl2:
  fixes a::"'a::len word"
  shows "b < c \<Longrightarrow> a >> b << c = (a << (c - b)) AND (NOT (mask c))"

Output:
apply(rule word_eqI)
apply(auto simp:nth_shiftr nth_shiftl word_size word_ops_nth_size) done


Input:
lemma bet_per_suma__per123:
  assumes "Per D E F" and
    "Bet G H I" and
    "A B C D E F SumA G H I"
  shows "Per A B C"

Output:
using bet_per_suma__per456
by (meson assms(1) assms(2) assms(3) suma_sym)


Input: lemma unit_mult_left_cancel: "a dvd 1 \<Longrightarrow> a * b = a * c \<longleftrightarrow> b = c"

Output:
using mult_cancel_left [of a b c]
by auto


Input:
lemma sum_union_disjoint':
  assumes "finite A"
    and "finite B"
    and "A \<inter> B = {}"
    and "A \<union> B = C"
  shows "sum g C = sum g A + sum g B"

Output:
using sum.union_disjoint[OF assms(1-3)] and assms(4)
by auto


Input:
lemma is_ang_conga:
  assumes "A B C Ang a" and
    "A' B' C' Ang a"
  shows "A B C CongA A' B' C'"

Output:
using Ang_def ang_conga assms(1) assms(2)
by auto


Input:
lemma suppa_right_comm:
  assumes "A B C SuppA D E F"
  shows "A B C SuppA F E D"

Output:
using SuppA_def assms conga_left_comm
by auto


Input:
lemma per_not_col:
  assumes "A \<noteq> B" and
    "B \<noteq> C" and
    "Per A B C"
  shows "\<not> Col A B C"

Output:
using assms(1) assms(2) assms(3) l8_9
by auto


Input:
lemma MutuallyDistinct_Union:
  "\<lbrakk> MutuallyDistinct A; MutuallyDistinct B;
  (\<Union> C \<in> A. States C) \<inter> (\<Union> C \<in> B. States C) = {} \<rbrakk>
  \<Longrightarrow> MutuallyDistinct (A \<union> B)"

Output: by (unfold MutuallyDistinct_def, safe, blast+)


Input:
lemma l2_11_b:
  assumes "Bet A B C" and
    "Bet A' B' C'" and
    "Cong A B A' B'" and
    "Cong B C B' C'"
  shows "Cong A C A' C'"

Output:
using assms(1) assms(2) assms(3) assms(4) l2_11
by auto


Input:
lemma tndFalse: "(\<forall>a b c d. (a,b)\<in>A  \<and> (c,d)\<in>B \<longrightarrow> twoNetsDistinct a b c d) \<Longrightarrow>
        \<exists>(a, b)\<in>A. a \<in> subnetsOfAdr (D::('a::adr)) \<and> b \<in> subnetsOfAdr (F::'a) \<Longrightarrow>
        \<exists>(a, b)\<in>B. a \<in> subnetsOfAdr D\<and> b\<in> subnetsOfAdr F
    \<Longrightarrow> False"

Output:
apply (simp add: twoNetsDistinct_def)
apply (auto simp: ndFalse1 ndFalse2)
apply (metis soadisj) done


Input:
lemma overlap_ordering_alt2:
  assumes abc: "ord a b c"
      and bcd: "ord b c d"
      and abd: "ord a b d"
      and acd: "ord a c d"
      and ord_distinct: "\<forall>a b c. (ord a b c \<longrightarrow> a \<noteq> b \<and> a \<noteq> c \<and> b \<noteq> c)"
  shows "\<exists>f. ordering f ord {a,b,c,d}"

Output: by (metis assms overlap_ordering)


Input:
lemma betw_a_in_path:
  assumes abc: "[[a b c]]"
      and path_ab: "path bc b c"
  shows "a \<in> bc"

Output:
using assms abc_ex_path_unique path_unique
by blast


Input:
lemma out_one_side_1:
  assumes "\<not> Col A B C" and
    "Col A B X" and
    "X Out C D"
  shows "A B OS C D"

Output:
using assms(1) assms(2) assms(3) not_col_permutation_2 one_side_reflexivity one_side_symmetry os_out_os
by blast


Input:
lemma midpoint_distinct:
  assumes "\<not> Col A B C" and
    "Col A B X" and
    "X Midpoint C C'"
  shows "C \<noteq> C'"

Output:
using assms(1) assms(2) assms(3) l7_3
by auto


Input:
lemma pos_less_divide_eq [field_simps]:
  assumes "0 < c"
  shows "a < b / c \<longleftrightarrow> a * c < b"

Output:
using assms local.dual_order.strict_iff_order local.nonzero_divide_eq_eq local.pos_le_divide_eq
by auto


Input: lemma strict_weak_trans: "a \<prec>[le] b \<Longrightarrow> b \<preceq>[le] c \<Longrightarrow> a \<prec>[le] c"

Output:
unfolding strongly_preferred_def
by (blast intro: trans)


Input:
lemma coplanar_perm_4:
  assumes "Coplanar A B C D"
  shows "Coplanar A D B C"

Output:
proof - obtain X where P1: "(Col A B X \<and> Col C D X) \<or> (Col A C X \<and> Col B D X) \<or> (Col A D X \<and> Col B C X)"
using Coplanar_def assms
by blast then show ?thesis
using Coplanar_def col_permutation_4
by blast
qed


Input:
lemma poincare_mapsto_cong: "closed A \<Longrightarrow>
    poincare_mapsto A B C D E = c1_on_open_euclidean.poincare_mapsto g Y A B C D E"

Output:
using poincare_mapsto_congI1[of A B C] poincare_mapsto_congI2[of A B C]
by auto


Input:
lemma sorted_mult_spvec_spmat[rule_format]:
  "sorted_spvec (c::('a::lattice_ring) spvec) \<longrightarrow> sorted_spmat B \<longrightarrow> sorted_spvec (mult_spvec_spmat c a B)"

Output:
apply (induct c a B rule: mult_spvec_spmat.induct)
apply (simp_all add: sorted_addmult_spvec) done


Input:
lemma Int_interval_mixed_eq_empty:
  fixes a :: "'a::euclidean_space"
   assumes "box c d \<noteq> {}"
  shows "box a b \<inter> cbox c d = {} \<longleftrightarrow> box a b \<inter> box c d = {}"

Output: unfolding closure_box[OF assms, symmetric] unfolding open_Int_closure_eq_empty[OF open_box] ..


Input: lemma dvd_gcdD1: "a dvd gcd b c \<Longrightarrow> a dvd b"

Output:
using gcd_dvd1 [of b c]
by (blast intro: dvd_trans)


Input:
lemma lea_out4__lea:
  assumes "A B C LeA D E F" and
    "B Out A A'" and
    "B Out C C'" and
    "E Out D D'" and
    "E Out F F'"
  shows "A' B C' LeA D' E F'"

Output:
using assms(1) assms(2) assms(3) assms(4) assms(5) l11_30 l6_6 out2__conga
by auto


Input:
lemma bound_on_path:
  assumes "Q\<in>\<P>" "[f[(f 0)..]X]" "X\<subseteq>Q" "is_bound_f b X f"
  shows "b\<in>Q"

Output:
proof - obtain a c where "a\<in>X" "c\<in>X" "[[a c b]]"
using assms(4)
by (metis ordering_def inf_chain_is_long is_bound_f_def long_ch_by_ord_def zero_less_one) thus ?thesis
using abc_abc_neq assms(1) assms(3) betw_c_in_path
by blast
qed


Input:
lemma Disj_E:
  assumes A: "insert A H \<turnstile> C" and B: "insert B H \<turnstile> C" shows "insert (A OR B) H \<turnstile> C"

Output: by (metis A B Disj_mono NegNeg_I Peirce)


Input:
lemma inangle__lta:
  assumes "\<not> Col P B C" and
    "P InAngle A B C"
  shows "A B P LtA A B C"

Output: by (metis LtA_def TS_def Tarski_neutral_dimensionless.conga_cop__or_out_ts Tarski_neutral_dimensionless.conga_os__out Tarski_neutral_dimensionless.inangle__lea Tarski_neutral_dimensionless.ncol_conga_ncol Tarski_neutral_dimensionless_axioms assms(1) assms(2) col_one_side_out col_trivial_3 in_angle_one_side inangle__coplanar invert_two_sides l11_21_b ncoplanar_perm_12 not_col_permutation_3 one_side_reflexivity)


Input:
lemma out213_suma__conga:
  assumes "A B C D E F SumA G H I" and
    "B Out A C"
  shows "D E F CongA G H I"

Output:
using assms(1) assms(2) out546_suma__conga suma_sym
by blast


Input:
lemma card_mono_strict_subset:
  "finite A \<Longrightarrow> finite B \<Longrightarrow> finite C \<Longrightarrow> A \<inter> B \<noteq> {} \<Longrightarrow> C = A - B \<Longrightarrow> card C < card A"

Output: by (metis Diff_disjoint Diff_subset inf_commute less_le psubset_card_mono)


Input: theorem th2_4: "a b \<congruent> c d \<Longrightarrow> b a \<congruent> c d"

Output:
proof - assume "a b \<congruent> c d" with th2_3 [of b a a b c d] and A1' [of b a] show ?thesis
by simp
qed


Input:
lemma (in aGroup) ag_add4_rel:"\<lbrakk>a \<in> carrier A; b \<in> carrier A; c \<in> carrier A;
 d \<in> carrier A \<rbrakk> \<Longrightarrow> a \<plusminus> b \<plusminus> (c \<plusminus> d) =  a \<plusminus> c \<plusminus> (b \<plusminus> d)"

Output: apply (simp add:pOp_assocTr43[of "a" "b" "c" "d"], simp add:ag_pOp_commute[of "b" "c"], simp add:pOp_assocTr43[THEN sym, of "a" "c" "b" "d"]) done


Input:
lemma
  assumes "FI_RESULT [(A, A)] (B * C * D) emp F"
  shows "FI_QUERY (B*C*D*A) (A) F"

Output:
apply (tactic \<open>Seplogic_Auto.match_frame_tac (resolve_tac @{context} @{thms ent_refl}) @{context} 1\<close>)
by (rule assms)


Input:
lemma neg_le_divideR_eq [field_simps]:
  "a \<le> b /\<^sub>R c \<longleftrightarrow> b \<le> c *\<^sub>R a" (is "?P \<longleftrightarrow> ?Q") if "c < 0"
    for a b :: "'a :: ordered_real_vector"

Output:
using that pos_le_divideR_eq [of "- c" a "- b"]
by simp


Input:
lemma between_equality_2:
  assumes "Bet A B C" and
    "Bet A C B"
  shows "B = C"

Output:
using assms(1) assms(2) between_equality between_symmetry
by blast


Input: lemma meta_all3_eq_conv: "(\<And>a b c. a = d \<Longrightarrow> PROP P a b c) \<equiv> (\<And>b c. PROP P d b c)"

Output:
apply(rule equal_intr_rule)
apply(erule meta_allE)+
apply(erule meta_mp)
apply(rule refl)
apply(erule meta_allE)+
apply simp done


Input:
lemma uprod_eq_simps [simp, code]:
  "uprod_eq eq (Upair a b) (Upair c d) \<longleftrightarrow>
   Rep_equal eq a c \<and> Rep_equal eq b d \<or> Rep_equal eq b c \<and> Rep_equal eq a d"

Output:
supply Upair.transfer[transfer_rule]
by transfer simp


Input:
lemma
  add3: "ccw 0 a b \<and> ccw 0 a c \<Longrightarrow> ccw 0 a (b + c)"

Output:
using add1[of "-b" a "-c"] uminus1[of "b + c" a]
by simp


Input:
lemma lea_left_comm:
  assumes "A B C LeA D E F"
  shows "C B A LeA D E F"

Output: by (metis assms conga_pseudo_refl conga_refl l11_30 lea_distincts)


Input:
lemma wfC_refl:
  assumes "wfG \<Theta> \<B> ((x, b', c') #\<^sub>\<Gamma>\<Gamma>)"
  shows   "wfC \<Theta> \<B> ((x, b', c') #\<^sub>\<Gamma>\<Gamma>) c'"

Output:
using wfG_wfC assms wfC_replace_cons
by auto


Input:
lemma divide_lt:
  "\<lbrakk>c *R (a::'a) < b; (c::rat) > 0 \<rbrakk> \<Longrightarrow> a < (1/c) *R b"

Output:
using scaleRat_less1[of "c *R a" b "1/c"]
by (simp add: scaleRat_one scaleRat_scaleRat)


Input:
lemma gcd_unique_nat: "d dvd a \<and> d dvd b \<and> (\<forall>e. e dvd a \<and> e dvd b \<longrightarrow> e dvd d) \<longleftrightarrow> d = gcd a b"
  for d a :: nat

Output:
using gcd_unique
by fastforce


Input:
lemma osp_distincts:
  assumes "A B C OSP P Q"
  shows "A \<noteq> B \<and> A \<noteq> C \<and> B \<noteq> C \<and> A \<noteq> P \<and> B \<noteq> P \<and> C \<noteq> P \<and> A \<noteq> Q \<and> B \<noteq> Q \<and> C \<noteq> Q"

Output:
using OSP_def assms tsp_distincts
by blast


Input:
lemma split_gallery_fg:
  "\<lbrakk> C\<in>f\<turnstile>\<C>; D\<in>g\<turnstile>\<C>; gallery (C#Cs@[D]) \<rbrakk> \<Longrightarrow>
    \<exists>As A B Bs. A\<in>f\<turnstile>\<C> \<and> B\<in>g\<turnstile>\<C> \<and> C#Cs@[D] = As@A#B#Bs"

Output:
using folding_f.split_gallery flopped_half_chamber_systems_fg
by simp


Input:
lemma ereal_mult_strict_left_mono:
  "a < b \<Longrightarrow> 0 < c \<Longrightarrow> c < (\<infinity>::ereal) \<Longrightarrow> c * a < c * b"

Output:
using ereal_mult_strict_right_mono
by (simp add: mult.commute[of c])


Input: lemma delete_bal: "\<lbrakk>k > 0; bal t; root_order k t\<rbrakk> \<Longrightarrow> bal (delete k x t)"

Output:
using del_bal
by (simp add: reduce_root_bal)


Input:
lemma lookup_delete [simp]:
  "lookup (delete k t) = (lookup t)(k := None)"

Output: by transfer (simp add: rbt_lookup_rbt_delete restrict_complement_singleton_eq)


Input: lemma invKey_eq [simp]: "(invKey K = invKey K') = (K=K')"

Output:
apply (safe)
apply (drule_tac f=invKey in arg_cong, simp) done