constructor intro have rw exact h.antisymm rintro


constructor intro letI letI inferInstanceAs let have have intro rw apply_fun rwa rintro exact


let let rw not_nontrivial_iff_subsingleton,


rw intro obtain have rw obtain have apply trans rw rw simp obtain obtain apply simp rw simp


have rw have rw exact obtain rw obtain use


rw classical induction empty insert rw have have set obtain contrapose rw exact let have have rw convert simp_rw let specialize convert ext simp_rw rw simp_rw s.sum_neg_distrib, congr exact obtain rw intro exact


let have to choose pi_tensorProductMk_quotient_surjective it refine bijective_of_isLocalized_maximal rw which apply rw convert refine simp


classical let have not_isUnit_zero have not_isUnit_zero exact


have rw constructor intro rw apply exact exact rw rintro have simp rw exact intro rwa rw exact


classical have apply let conv_rhs apply rw apply let choose conv_rhs refine apply rw exact


by_cases simp have have have obtain have ext obtain simp rw exact


obtain obtain obtain simp not_or, refine rw simpa


PrimeSpectrum.preimageHomeomorphFiber

letI refine have exact exact continuous_toFun convert ext1 obtain simp simp continuous_invFun


refine apply obtain obtain apply simp simp


instIsAlgebraicResidueFieldOfIsIntegral

have letI haveI haveI haveI refine obtain simp refine


Polynomial.fiberEquivQuotient

refine simp change rw have exact apply ext simp ext obtain simpa


obtain exists_le_maximal rintro exact apply rwa


refine rw intro obtain obtain obtain simp use rw have rw exact refine rw map_sub, rw exact


have simpa have rw equivQuotMaximalIdeal_apply_mk,


rw apply intro obtain have rw obtain obtain refine rw exact obtain obtain refine rw rwa rw have rw refine rw apply exact


haveI rw refine rw intro obtain obtain obtain obtain obtain refine rw rwa rw use rw map_sub, rw refine rw apply exact simp rw


obtain obtain obtain simp use rw have have have rwa refine rw comap_map_eq_self_of_isMaximal inv_mul_cancel_right₀


have have have rw equivQuotientMapOfIsMaximal_apply_mk, equivQuotientMapOfIsMaximal_apply_mk,


have rw exact have by_cases simp_rw ramificationIdx_bot have rw exact have rwa ramificationIdx_map_self_eq_one rw exact


obtain refine simp obtain use simp obtain use rw


IsLocalization.Away.mul

refine simp exact obtain obtain use simp ring repeat obtain simp obtain use convert_to ring ring rw


have wlog have have refine replace classical have this exact have refine existsUnique_of_exists_of_unique algebraMap_injective_of_span_eq_top obtain choose let let have rw have simp_rw choose let have rw mul_assoc, let let have rw have rw have refine simp_rw smul_eq_mul


rcases rw have rw rw have rw rw rw congr ext simp


rw constructor intro have simp rwa intro have simp rwa


obtain obtain have haveI simp apply rw apply exact exact simp obtain refine rw mul_comm exact


rw intro haveI inferInstanceAs have rw intro rw refine use rw have rw apply simp rw obtain rw obtain simp use simpa


instIsLocalizedModuleFinsuppLinearMap

classical let let finsuppRight suffices convert ext simp rw convert ext apply ext apply suffices simpa split_ifs simp simp


let classical refine obtain obtain simp_rw rw obtain refine obtain simpa simp obtain exact


IsLocalization.atUnits

refine intro obtain obtain rwa intro obtain obtain use dsimp rw simp


constructor intro convert exact intro obtain apply_fun simp exact intro rw exact


refine have have apply_fun rw have exact


letI constructor rintro convert dsimp exact intro obtain refine dsimp convert intro rw simp


letI refine intro convert rw exact rw simp apply intro rw


refine have let mem_nonZeroDivisors_of_injective exact


rw mem_nonZeroDivisors_iff_ne_zero.2 hx one_mul, rw exact


have obtain let refine exact intro have simp change replace simp apply rw simp


constructor change refine obtain let use simp rintro rw exact


refine simp obtain simp obtain rw refine rwa


have contrapose rw obtain exact refine rw obtain replace obtain have rw exact exact


constructor refine refine rw exact intro rw exact refine rwa intro obtain obtain have rw have rw rwa


rw constructor rintro exact rintro exact


apply simp intro apply rintro simp obtain dsimp rw obtain use dsimp rw exact


intro obtain obtain by_cases have rw rw convert rw exact rw obtain obtain refine replace rw rw simp refine rw


have hM.trans have have algebraMap apply simp rw intro obtain simp obtain simp exact


haveI refine exact rw congr refine rw rfl


delta rw ext constructor rintro rw exact rintro exact


classical use intro rw split_ifs exact rw


refine obtain constructor rw have rw apply intro apply exact


constructor refine have exact exact exact


by_cases exact haveI obtain refine refine rwa refine refine rw exact


intro obtain obtain obtain refine replace rw exact obtain exact


rw intro rw by_cases on_goal rwa have rw change apply exact rw exact rw rw exact


rcases haveI exact obtain have obtain refine rw exact rw exact rwa


nontriviality let obtain obtain have obtain exact let have by_cases exact simp_all let have letI rw simp refine refine refine grw simp simp rw simp intro have add_comm simpa coeff_eq_zero_of_natDegree_lt simp trans simp simp_rw


IsLocalization.integralClosure

refine rintro convert simp rintro obtain simp obtain simp obtain simp exact refine apply simp ring rintro have have obtain refine simpa


simp constructor intro letI letI have rw obtain obtain rw refine exact intro obtain use rw exact


intro obtain obtain obtain have refine rwa have map_mem_nonZeroDivisors have rw exact suffices rw div_eq_mul_inv, exact refine rw exact


constructor intro obtain apply rw apply apply apply exact change rw apply apply exact


have rw rcases refine rw rintro change rw trivial


rw constructor rintro exact rintro exact


rcases rcases rcases dsimp refine rw refine rw simp ring


rw rintro rcases dsimp suffices obtain refine rw refine rw rwa rw


convert dsimp congr symm rw rintro exact


have refine exact rintro obtain use rw refine intro apply rw apply rw


haveI haveI apply intro rw intro apply rw exact


cases exact have choose use rw intro refine hf simp_rw


obtain obtain obtain refine refine simp rw


constructor have obtain refine rw refine rw


constructor intro refine rintro exact exact rintro refine z rw smul_smul] congr rw rw rintro obtain refine rw mul_mk'_eq_mk'_of_mul] rintro exact


refine constructor rw rintro refine rw rintro refine rw


simp convert conv_lhs refine dsimp split_ifs


refine intro ext simp intro simp split_ifs funext simp


refine simp intro simp intro rw dsimp split_ifs constructor simp


classical cases simp unfold split norm_cast simpa apply


constructor intro constructor apply simp apply rw norm_cast simp rw apply


cases simp contrapose simp exact apply simp


have rw apply apply apply exact simp rw apply simp apply exact


by_cases rw simp rintro nth_rw simp obtain have simpa simpa simp


have have have have not_or_intro rw exact


classical induction empty simp exact insert


rw refine rintro simp_rw by_cases rw convert rw rw rw rw


rw refine classical intro simp have intro simp exact rw apply simp


have classical rw ext rw simp intro apply simp have simp nth_rewrite rw leadingCoeff] rw constructor classical apply simp apply rw exact intro simp nth_rewrite rw rw exact


MonomialOrder.div

by_cases obtain use constructor simp simp nth_rewrite rw constructor intro by_cases apply simp apply simp apply simp apply simp by_cases refine intro simp exact by_cases obtain have apply intro apply simpa obtain use use constructor rw simp constructor rintro simp rw apply simp constructor exact classical rw split_ifs subst grw simp exact exact suffices obtain use constructor simp constructor exact intro by_cases exact convert classical have rw simpa by_cases refine intro simp exact exact termination_by decreasing_by exact apply intro apply simp nth_rewrite simp


obtain specialize set simp simp refine rw simp add_left_inj] rw simp


refine induction zero succ grw apply simp induction zero add monomial convert rw


MvPolynomial.IsHomogeneous.prod

classical revert refine intro simp intro simp apply grind


apply intro rw apply convert rw rw simp_rw rintro apply


obtain let let let let have suffices convert dsimp rw simp


have have linarith use have intro rw apply simp rw exact simp_rw map_sum, contrapose ext rw obtain apply contrapose ext rw by_cases have simp rw exact simpa


induction zero use contrapose ext simpa succ have linarith obtain contrapose exact have contrapose exact obtain exact have obtain obtain set have have refine norm_cast refine suffices rintro refine simpa obtain use rwa


contrapose obtain have have obtain obtain use rwa


apply simp simp rw intro obtain obtain simpa


classical apply all_goals rw intro rw exact rw convert rw


classical let let have obtain he obtain he refine simpa


classical have let let let have have simp have simp rw apply grind simp suffices exact rintro obtain obtain obtain have simp simpa disjoint have simpa


apply apply simp apply intros apply simp rw intro obtain simp specialize simp intro apply intro simpa


classical let simp have rw simp rfl have have obtain apply rwa rwa simp rw suffices simpa simp intro apply intro simpa


constructor rw intro rw intro rw rw suffices obtain rw exact exact


rw rw rw rw apply intro apply rw simp exact


ext simp classical by_cases simp rw apply rw exact


conv_rhs rw simp intro by_cases left exact right apply simp simpa


apply apply apply simp apply rw intro rw apply simp apply


classical rw intro rw intro rw apply rintro simp dsimp by_cases rw suffices simp apply grw exact


classical rw rintro simp by_cases rw suffices rw rw intro apply suffices apply apply apply rw simp exact simp


induction zero succ simp apply simp exact


by_cases rw by_cases rw rw apply apply rw exact


by_cases simp apply apply apply simp rw simp


classical induction empty simp rw insert rw apply simp


classical induction empty insert simp rw exact


cases inl inr apply refine rw exact nonZeroDivisors.ne_zero


classical by_cases simpa apply by_contra simp apply rw simp


by_cases rcases right suffices nth_rewrite nth_rewrite ring rw intro apply apply contrapose rw


classical induction empty insert by_cases simp_all simp simp obtain use simp simp sPolynomial_self, simp trans suffices rw neg_mul, rw trans unfold congr apply intro rcases rw exact apply intro rw obtain simp


by_cases simp apply exact unfold apply intro exact


rw simp refine intro rw rw simp rintro have rw have intro rw have have rw simp exact all_goals


classical have funext simp rw have refine rw obtain simpa


have simp_rw symm rw apply intro congr intro rw congr


have supDegree_leadingCoeff_sum_eq rwa supDegree_single_ne_zero exact intro have simp_rw rw simp_rw have refine all_goals have rw by_contra exact rw


cases zero rw exact succ nontriviality exact


nontriviality induction zero add_single have rw map_add, map_nsmul, exact exact rwa


obtain rw exact rw by_contra apply pick_goal rw rw assumption refine all_goals conv_rhs rw apply simp_rw


rw refine rw refine sum_ne_zero_of_injOn_supDegree rw rwa rw dsimp rwa supDegree_esymmAlgHomMonomial


use rintro rw obtain exact induction subst let have rw exact rwa obtain convert have specialize rwa convert apply rw


intro obtain rw induction add mul_X rw apply rw refine simp_rw


intro rw split_ifs simp simp simp_all simp


rw rcases rw simp simp refine by_contra simp rw exact rw simp simp exact


rw rw have rw rcases rw simp card_erase_of_mem nth_rewrite simp have rw simp rw simp nth_rewrite simp rw simp


simp have rw have congrArg hesymm simp have simp filter_filter have ext rw refine rintro rw rw simp exact


rw obtain apply simp intro exact simp have rw simpa


classical rw intro rw obtain have contrapose by_cases rw


classical intro rw split_ifs subst exact contradiction


MvPolynomial.IsWeightedHomogeneous.prod

classical refine intro simp intro simp apply intro exact


simp apply simp exact obtain simp replace apply


suffices let add_mem zero_mem smul_mem simp_rw apply rw refine rw intro simp refine simp


classical rw intro rw exfalso apply nth_rw exact


classical rw ext1 simp rw rw intro rw intro rw simp have rw exact


classical ext rw by_cases split_ifs rfl rw rw


classical intro ext rw by_cases simp rw rw rw


simp ext rw by_cases split_ifs rw simp split_ifs rfl simp


classical rw convert rw intro exact rw intro


classical ext1 rcases simp rw simp simp obtain exact


simp rw apply intro rw constructor intro by_contra exact order


classical ext simp split_ifs rw exact rw exact exact rw exact


classical constructor rintro rw rintro rw contrapose dsimp subst rw rw exact intro refine ext by_cases rw rw simpa rintro rw rw split_ifs exfalso apply rw refine ext simp exact intro exfalso apply rwa rw rintro rw rw split_ifs exfalso apply rw ext rw exact contrapose ext by_cases subst simpa simp


induction empty simp split_ifs simp simp insert rw apply simp rintro rw apply simp rintro rw intro rw exact simp mem_attach, forall_exists_index, rintro obtain simp exact


classical rw apply intro rw set have have simp rw have simp rw rw apply rw suffices obtain rw rw apply simp rw convert simp simp simp intro rw exact


classical apply rw intro let have rcases use simpa have change filter_upwards simpa let let have have have hφ.comp filter_upwards simpa rw filter_upwards rw apply intro by_cases exact apply simp push_neg rcases exact


apply rw refine intro trans simp conv_lhs simp


classical contrapose simp obtain by_contra rw contradiction have rw have by_contra rw contradiction simp


classical refine intro obtain simp by_contra rw contradiction


by_cases simpa apply obtain have rw exact refine by_cases obtain rw simp exact obtain exact


ext by_cases obtain by_cases rw have obtain by_contra exact have exact rw obtain rw by_cases rw rw


classical rw intro use refine have simp congr ext simp rw trunc'_expand_trunc


MvPowerSeries.lexOrder

classical exact have simp apply apply exact exact


have have rcases simp suffices simp apply rw apply


constructor intro apply exact intro rw intro have rw exact obtain refine rwa


rw rintro simp rcases exact rw rw norm_cast rw rw norm_cast


rw intro rw apply rintro simp simp suffices rcases rw rw rw intro rw apply simp


obtain simp obtain simp rcases rcases apply rw apply rw exact


classical constructor simp intro constructor intro have simpa by_contra apply rw intro have rw split_ifs simpa rintro exact


classical rw refine intro refine rw convert intro refine simpa


simp_rw intro replace simp_rw constantCoeff_map] obtain use intro simpa


refine replace continuous_constantCoeff simpa


classical intro ext apply intro rw convert rw rintro suffices apply simp rintro simp_all simp


constructor intro have simpa intro ext have rw simpa


apply by_cases by_cases let have let have have simp intro rcases refine simp rw exact rw rw intro apply apply rw simp rw simp


constructor intro obtain exact f.coeff_eq_zero_of_lt_weightedOrder rintro exact


classical split_ifs rw rw constructor use simp intro rw rintro exact


obtain rw obtain constructor refine rw rw exact intro suffices rw coeff_eq_zero_of_lt_weightedOrder rw exact


classical apply intro rw rintro by_cases rw by_cases rw simp exfalso apply rw


classical induction empty insert simp rw


constructor intro apply simpa intro refine rw simp


intro obtain simp apply rw specialize simp exact


constructor intro ext rw split_ifs rfl exact intro rw exact


classical ext rw split_ifs apply intro rw rw simp rcases rw rw rw rw rw rw rw symm apply exact


rw intro obtain apply intro rw apply simp refine


classical simp refine simp split_ifs exact exact


classical simp refine by_cases obtain filter_upwards simp simpa


simp_rw constructor rintro exact intro choose exact


rcases apply rw simp_rw intro obtain refine simp_rw intro contrapose exact


rcases apply refine simp_rw obtain apply suffices intro contrapose obtain rw refine apply


rw intro by_cases simp have obtain by_contra exact simpa rw


classical rw apply intro by_cases rw apply simpa apply rw obtain rw apply rw simpa intro simp exact


classical apply intro rw intro by_cases simp rw refine simp exact


refine simp intro trans refine simp exact


classical ext simp split_ifs simp simp convert simp obtain simp apply simpa


ext simp smul_eq_mul] by_cases rw simp simp


classical ext rw rw simp rw simp intro rw intro simpa


ext by_cases symm simp intro have contradiction simp


classical simp apply rintro simp rw simp apply rw rw


induction base succ ext by_cases rw if_pos intro have have simp simp


have simp by_contra simp have refine simp intro simp exact rw exact


refine intro obtain obtain have rw exact


have le_antisymm have have simpa have hIJ rwa sup_comm


have have refine simpa have apply simpa rw simp have conv_lhs simp obtain refine induction smul₀ rw exact smul₁ add zero


rw apply rintro suffices by_cases rw rw linarith


classical induction empty insert rw apply exact apply exact


rcases simp_rw rw suffices simp_rw refine rw


obtain obtain let have have rw exp_eq_sum set set have calc refine rw simp_rw refine simp replace suffices rw smul_assoc] norm_cast rw simp rw apply simp lia simp rintro simp_all lia simp exact simp have sum_eq_zero rw cases inl inr have sum_filter_add_sum_filter_not rw rw have sum_eq_zero simp cases inl inr have sum_filter_add_sum_filter_not rw rw have apply ext simp lia tauto rw have calc rw refine rw rw apply exact simp simp rwa


ext obtain obtain let replace replace have simpa simp


let let have have have set have suffices apply ext simp have have simp


obtain use ext replace simp_rw rw ext exact


rw simp rw simp have by_cases simp simp obtain simp simp exact pow_zero


obtain set simp replace intro obtain apply simpa have simp rw apply have replace h2 exact nth_rw rw rw simpa


induction zero refine rw by_contra have have obtain have exact succ by_cases have exact obtain set have obtain have exact intg.trans


suffices obtain use rintro cases apply exact obtain refine simpa


let constructor intro let exact intro constructor intro obtain convert refine by_contra obtain apply rw sup_le exact


obtain monotone_stabilizes_iff_noetherian.mpr refine rw rintro apply replace simpa rwa


obtain monotone_stabilizes_iff_noetherian.mpr refine refine rcases rw exact


refine obtain obtain refine simp exact suffices exact


haveI obtain monotone_stabilizes_iff_noetherian.2 exact


induction mem induction mem zero mul add neg zero mul add neg


ext refine rintro rintro refine refine exact


induction mem induction mem zero mul add zero mul add


classical let let haveI clear_value simp_rw simp exact


haveI have rw hf.coeff_zero_eq_prod_roots_of_monic simp


constructor swap rintro let let rw rintro rw refine simpa contrapose apply rw


haveI haveI letI rw refine letI simp_rw congr exact intro simp


classical by_cases obtain letI letI rw congr ext simp rw intro exact


induction zero rw simp_rw succ have let let have refine sub_eq_zero.mp mem_nonZeroDivisors_iff_right.mp rw exact rw


classical nontriviality nontriviality have let let have have cases rw det_eq_one_of_not_module_finite cases rw det_eq_one_of_not_module_finite rw det_toMatrix


by_cases swap simpa let rw norm_algebraMap_of_basis apply rw norm_gen_eq_prod_roots refine suffices obtain simp


by_cases swap rw by_cases have h have exact simp rw simp refine rw exact let nth_rw rw norm_algebraMap_of_basis


have rw norm_eq_prod_embeddings_gen exact haveI exact


refine rw apply rintro obtain refine rw exact


simp apply apply have rw have ext exact simp


rw suffices isArtinian_of_surjective_algebraMap rw exact


simp have generalize generalize rw rcases have rcases use use simp constructor rw rw


induction induction induction rcases rcases simp simp_rw congr rw rw


induction induction induction rcases rw rw rw repeat simp


induction rw have rintro simp simp with_unfolding_all


induction induction induction rcases rw clear rw rcases rw clear have rw norm_cast apply rw have rw rcases rw rw rw simp rw rw simp


obtain haveI letI letI let haveI let replace let replace simpa


intro refine induction refl le_succ_of_le choose use intro obtain have simp exact subst simp have have simp simp


by_cases rw by_cases rw by_cases rw obtain obtain rw rw


obtain obtain have rw rw rw rw mul_one_div_cancel rw by_cases rw replace conv_lhs rw refine rw


have rw classical obtain induction zero succ obtain have have rw exact rw


by_cases rw by_cases rw obtain obtain replace replace have rw refine rw rw rw rw


by_cases rw by_cases rw by_cases rw replace replace replace obtain replace replace replace rw rcases exact exact


by_cases rw obtain change rw replace rwa


intro simp intro simp apply_fun simp simp exact


apply eq_of_apply_teichmuller_eq use have rw exact simp


have have rw infer_instance apply simp suffices rwa have ext simp rw apply exact exact


cases zero succ let have simp rw refine rw simp calc


cases zero succ simp nth_rw refine rw simp


let let have let have rw use simp_rw rw rwa have classical let let let have refine simp


refine nontriviality have have card_eq_of_linearEquiv linearEquiv have exact considering see


let let refine apply ext apply let have have ext refine suffices conv_lhs rw mul_one]


obtain classical rw set obtain choose let restrict exact have dsimp exact let have simp simp_rw set have ext have injective_of_comp_eq_id rw refine rw map_top,


ext obtain exact mk_eq_one_iff.mpr have have refine mk_eq_iff.mpr have eq_span_singleton_of_surjective tensorSubmoduleAlgebraEquivMul rw apply_fun simp_rw obtain exact


have have have isRightRegular_iff_isRegular.mp rw convert rw constructor exacts


refine simp intro dsimp rw simp_rw conv_rhs simp rfl intro simp


refine intro simp intro rw toFunAlgHom_apply_tmul, simp


let have ψ.range.val.comp simp simp rw quotientKerEquivRangeₐ_comp_mkₐ simp apply rw rTensor_comp_apply, apply simp rw comp_toLinearMap, simp


rintro simp set have rw exact set have rw exact have simp simp obtain rw have have have rTensor rTensor rTensor_surjective obtain rw simp rw simp rfl simp congr


obtain suffices obtain use rw simp exact


classical intro obtain obtain obtain exact


classical obtain have obtain have rw obtain have rw apply simp exact use


classical obtain let let rintro simp simp exact let have ext simp congr ext simp let have simp rw comp_toLinearMap] apply simp simp congr ext simp simp


apply intro replace rw refine have rw refine rw intro apply exact


by_contra by_cases rw rcases exact have refine rw exact rwa


rw push_neg intro rcases have rw exact rw exact


ext trans simp rw simp simp if_true, induction zero succ simp coeff_X_add_one_pow]


nontriviality obtain rw refine refine rw simp simp intro exact rw exact


constructor intro refine intro obtain rw by_cases simpa simp simp exact refine rw exact intro rw refine simp rw exact


simp constructor rintro rcases refine rw exact refine rw rintro have refine apply apply rw rw


rw simp constructor rintro exact rintro exact intro exact


classical induction empty rw exact insert rw apply rintro obtain apply rw exact


nontriviality intro obtain have have rw exact


constructor intro have convert ext simp constructor rintro rwa simp intro simpa intro constructor rw use rw exact intro simp contrapose rintro classical let let refine rw apply rw exact apply rintro rw simp obtain rw apply exact apply exact


let nth_rw refine dsimp have apply rw use have convert simp rw


have rw convert_to congr simp induction zero succ convert simp simp


classical symm let have apply intro simp intro simp apply_fun simp rw


rw intro rw rcases use use use use simpa


apply intro rw rcases have calc aeval rw have calc aeval rw refine rw simpa


rw apply apply intro simp_rw apply apply have rw apply rw exact apply rintro apply exact


classical constructor intro refine intro obtain rw by_cases simpa simp simp exact refine rw exact intro rw suffices exact intro rw suffices apply exact


rw suffices simpa zero_add, bernsteinPolynomial, conv_rhs rw refine simp apply exact rw rw norm_cast congr convert convert simp apply


rcases rintro rw induction zero succ ih simp intro apply rw convert exact


by_cases induction zero succ have simp tsub_zero, eval_sub, obtain simp have rw rw_mod_cast rw simp


simp simp norm_cast apply obtain simp rw exact


rw simp sub_self, obtain simp norm_cast congr lia


induction zero succ apply fconstructor exact clear simp simp dsimp apply notMem_span_of_apply_notMem_span_image simp intro apply_fun simp suffices rw exact refine simp rintro rw simp intro intro


let let have have let cond trans have k rintro simp rw simp push_cast ring rw refine simp add_zero, rw simp


let let have have let cond trans have rintro simp simp rw simp push_cast ring rw refine simp add_zero, simp add_zero, add_sub_cancel,


bernsteinPolynomial.variance

have n rfl conv lhs rw simp simp simp conv rhs rw calc congr cases simp cases simp simp


Polynomial.Chebyshev.induct'

refine have intro cases zero succ apply convert


induction zero one add_two ih2 have rw norm_cast rw rw rw neg


induction zero one add_two ih2 have change rw rw norm_cast rw tauto neg


induction zero one add_two trans simp ring_nf simp neg


induction zero one norm_cast rw more push_cast have rw norm_cast rw rw rw


obtain rw rw cases zero succ cases zero succ trans congr rw


induction zero one more trans push_cast rw simp simp


induction zero one add_two have have have linear_combination neg_add_one have have have linear_combination


induction zero succ have linear_combination pred have linear_combination


induction zero one add_two have have have simp linear_combination neg_add_one have have have simp linear_combination


have simp sub_add_cancel, have rw linear_combination


induction zero one add_two have have simp linear_combination neg_add_one have have simp linear_combination


rw refine have ext simp rcases simp rw constructor intro use rintro rw apply rw simp refine ext rw simp


rw constructor ext by_cases rw rw push_neg simp intro simp


apply rw intro apply apply intro simp contrapose intro apply


rw constructor intro apply intro rw intro apply


by_cases simp unfold refine rw apply conv_rhs simp rw


classical have rcases refine suffices clear by_contra rcases have contrapose simp have rw by_cases rw normalize_eq_one] rw apply have rw apply refine rw rw have nontriviality have rw rw rcases apply rw


constructor rintro rw exact rintro rw gcongr


constructor rw intro calc apply rwa rw exact


refine contrapose simp intro use simp_all


rw intro rw rw simpa contentIdeal_eq_bot_iff,


classical rw simp rw have symm apply rw exact


rw have apply intro exact rw simp refine rw intro exact


refine induction rcases use simp let have apply intro exact have refine intro have obtain rw exact replace obtain let have constructor rw simpa replace simp use rw simp


rw rw rcases simp rw exact simp one_ne_zero]


suffices simpa map_dvd rcases simp rw apply simp


rcases simp have intro rw rw simp_rw simp intro apply apply


nontriviality rw have apply intro exact rw simp constructor rw rw intro exact


rw induction obtain simp have intro obtain rw exact rw


nontriviality refine rw have apply intro exact rw refine rw intro exact


have intro have rw rw induction zero succ rw rw rw rw simp


induction have rw have intro apply exact have intro exact have rw simp simp have rw have rw simp rw exact


apply rw intro replace rw by_cases simp coeff_sub] rw exact


apply suffices simp apply simp rw rw eval_mul,


by_cases simp congr rw convert simp simp


let apply rw simp_rw have rw refine have obtain exact


haveI rw suffices rw simpa simp have rw by_contra have obtain rw rw exact


induction have have have apply_fun rw eval_geom_sum] rcases apply rwa rw refine simp rw rcases refine exact exact rcases simpa refine rintro exact rw exact apply rwa rw have rw exact rw apply refine simp refine rintro rw exact simpa


rcases simp simp simp constructor constructor


rcases simp have rsuffices have simpa exfalso linarith rw intro haveI have apply_fun rw simp_rw rw swap simp not_exists, exact rw obtain rw have simp exact rintro apply exact


have have have intro rw convert rw rw let have have refine suffices convert simp rw push_neg refine rw clear_value rintro linarith have suffices simp convert rw simp simp convert swap simp simp norm_nonneg, intro simpa simp simpa


have have have intro rw convert rw rw let have have refine suffices convert rw symm exact simp rw push_neg refine rw intro rw have clear_value rintro exact have rw rw linarith contrapose apply have suffices simp convert rw simp rw linarith simp convert swap simp simp intro have simp simp obtain exact


rcases simp haveI suffices rw refine eq_of_monic_of_dvd_of_natDegree_le refine rw refine replace exact have have rw refine rw convert rw have rw refine rw map_cyclotomic, exact rw natDegree_cyclotomic,


rcases simp haveI suffices rw refine have have rw refine rw convert rw rw


rcases simpa obtain induction zero succ have rw exact


rcases rw refine rw replace rwa rw rw exact


have have have have have suffices have exact simpa let rw have isOfFinOrder_iff_pow_eq_one.mpr refine dvd_antisymm simp nth_rewrite rw simpa let have simp rw natCast_eq_natCast_iff,


rcases exact have rw convert convert apply exact


have refine have rw exact by_contra have have rw obtain replace rw rw have have rw have obtain obtain have rw have rw specialize simp


obtain exact rw refine hζ.nthRoots_one_nodup


intro simp rcases rw replace rwa haveI rw replace replace rw have have rw haveI rw replace rwa


rcases exact rcases exact rw exact h cyclotomic_injective eq_of_monic_of_associated


haveI let have have trans rw refine rw have obtain simp lift simp


nontriviality rw intro rw change rw intro rw change rw


have rw simp congr apply simp simp apply rw apply rw


obtain let let have rw infer_instance haveI refine apply rw apply apply rintro simp dickson_one_one_eval_add_inv intro rw apply suffices rw clear refine h.biUnion let have intro have simpa one_ne_zero] classical convert ext1 simp eval_add, by_cases simp apply rw apply ring apply intro simp by_cases simp exact simp exact


Polynomial.IsWeaklyEisensteinAt.mul

rw intro rw refine rcases exact replace by_contra rw replace linarith exact


rw sum_range, replace have intro exact choose conv_rhs congr congr skip ext rw rw refine exact


intro obtain rw suffices rw hmo.coeff_natDegree, rw exact


set have have simp obtain simp exact have rw exact simp_all obtain set have have obtain obtain suffices simp rw use intro rw rw suffices obtain apply apply rwa by_contra apply rw


apply generalizedEisenstein monic_X simp rw exact rw simp congr ext simp simp split_ifs rw exact by_cases exact rw exact simp rw convert rw rw ext exact


have rw have constructor simp intro simp


refine rw refine rw exact rw conv congr congr skip congr skip ext rw rw simp exact rw one_geom_sum, intro obtain have have cases


refine rw refine rw exact induction zero intro rw exact succ intro rw show map_X, coeff_expand simp rintro rw rw rw replace rw show simpa exact rw zero_add, simp intro obtain have have cases


choose rw conv_lhs congr skip ext rw rw rw exact


have roots_mem_integralClosure rw refine rw obtain rw rw apply rw refine exact


have suffices obtain use rw have rwa rw exact let have have refine use rw exact


refine irreducible_iff.mpr obtain obtain have rw rw rw refine exact by_contra refine rw exact


constructor intro intro refine rw apply rw


rcases obtain rw apply rw refine replace rw rcases apply apply


rcases obtain rw have use apply rw simp have rw exact symm rcases use rw iterate apply rw contrapose simp


let have apply apply rw exact refine simp mem_support_iff] grind


by_cases simp simp apply apply intro by_cases exact simp_all obtain simp rw exact


obtain clear induction zero succ have rw


induction zero rw exact succ cases zero rw rw succ rw rwa rw exact


rcases rw obtain rw coeff_hermite_explicit] simp


rw induction zero succ replace have rw simp rw hermite_succ, ring apply apply simp


delta induction zero succ simp rw sum_smul_index simp


use use exact rintro apply apply rintro simp rw


by_cases rw rcases have simp exact rw hilbertPoly]


rcases have simp exact nth_rw delta apply apply apply rw have simp pow_eq_zero_iff', exact


have intro rw exact have by_contra exact exact


rw constructor rcases simp rcases rcases exact


constructor intro induction mem obtain exact zero add obtain obtain exact smul obtain have refine rw exact rintro have trans ext1 simp congr simp simp_rw exact


rw have have have have use have apply_fun dsimp rw exact exact


rw split_ifs simp tsub_add_cancel_of_le simp by_cases rw rw exact simp


ext rw split_ifs simp simp by_cases rw rw exact simp


nontriviality have by_cases ext refine simp intro split_ifs


let let nilradical_le_prime let rw replace refine wlog exact have obtain simpa show refine isUnit_of_coeff_isUnit_isNilpotent have rw rw exact show sum_mem


classical induction empty insert rw exact


classical obtain rw refine have rw simpa rintro obtain simp


nontriviality obtain algebraize refine rw refine intro exact


IsAlmostIntegral.coeff

have obtain refine obtain simp by_cases simp have use simp rw rw induction h by_cases obtain simp split_ifs simpa exact by_cases simp have rw map_X refine obtain refine obtain exact simpa


IsIntegral.coeff

nontriviality nontriviality obtain let let have by_cases exact simp_all have rw refine refine refine dsimp simp grw have lia have have have simpa have change rw simpa have i).neg obtain simpa simp


classical by_cases rw zero_add, exact let rw have rw rintro refine ext simp split_ifs subst have hp grind simp have grind


classical apply intro obtain exact simpa


refine rw exact have obtain replace refine simpa rcases simpa simp apply simpa rcases simp simpa


obtain constructor refine have rwa intro rw intro let have rw have refine rw exact rw exact


induction zero succ have rw leadingCoeff_comp one_mul,


suffices apply_fun simpa induction zero succ conv_lhs rw add_assoc,


induction zero succ rw ascPochhammer_succ_right,


induction zero succ have rw cases simp refine


induction zero simp exact succ ih rw mul_add] exact


rw induction zero succ simp_rw obtain rw rw rw


induction zero succ have have rw one_pow]


suffices apply_fun simpa induction zero succ ih conv_lhs rw natCast_comp] rw


induction zero succ rw eval_mul_X, show simp ascPochhammer_eval_comp,


induction zero succ rw descPochhammer_succ_right,


induction zero succ ih rw eval_natCast_mul, by_cases rw rw


induction zero succ rw rcases simp simp lia


refine induction zero succ rw cases inl obtain exact inr obtain convert simp


induction zero succ rw have rw apply exact


induction zero succ intro rw have have simp_rw exact mul_le_mul


intro rw dsimp rw refine dsimp rw refine rw by_cases simpa simp


let have refine rw rw replace simp rwa obtain obtain refine simp suffices obtain mem_image_of_mem_map_of_surjective refine rw exact


rw rw refine simp refine suffices rw simp exact


intro apply intro obtain rw intro simp rw intro simp simp


intro obtain apply intro rw intro rw simp rw intro simp simp


induction rw apply exact cases rw apply i rw derivative_pow_succ, apply rw apply rw hy have hp rw exact


suffices simp haveI by_cases simp_all refine intro apply exact convert rw intro apply convert exact


suffices refine intro apply exact rw apply intro by_cases rw refine convert exact simpa rw rw exact


but obtain use have simpa have nth_rw rw


classical rw congr dsimp simp simp_rw simp finSumFinEquiv_apply_left, add_lt_add_iff_left, simp


obtain obtain let let let have induction zero succ rw congr ext simp neg_mul, obtain simp induction left dsimp have simp split_ifs rw exact lia right simp have simp rw lia lia rw congr ext induction


have simp exact rw set replace clear_value induction zero simp rw succ


let let let have induction zero succ suffices rw ext simp smul_eq_mul, obtain simp coeff_C_mul, induction left right lia rw congr ext induction


obtain simp rw rw simp finCongr_symm, congr trans congr simp simp rw simp ext simp induction left j have simp right j have simp simp split_ifs exact rintro suffices induction left b simp simp intros lia right


nontriviality obtain obtain simp conv_lhs rw simp rw lia


wlog trans rw simp simp generalize induction h by_cases obtain have rw rw by_cases obtain simp simp rw not_forall_not] obtain rw simp exact rw let have have simp have dsimp rw let have rw inv_mul_eq_iff_eq_mul₀ rw apply rw map_sub_sprod_roots_eq_prod_map_eval have trans congr refine simp mul_inv_cancel_left₀, intro conv_lhs simp simp simp congr exact simp rw simp


wlog let apply have this simp simpa by_cases simp wlog letI have rw have simpa simp clear by_cases subst by_cases obtain simp wlog letI have this rw simpa letI let apply have resultant_eq_prod_roots_sub simp_rw rw coeff_natDegree, map_sub_sprod_roots_eq_prod_map_eval simp congr


wlog exact surjective wlog exact injective wlog letI exact injective letI exact


wlog obtain simp ring_nf subst induction simp ring_nf injective apply have rw simpa surjective obtain obtain obtain rw simp_rw natDegree_eq_natDegree


induction by_cases obtain rw simp injective apply simpa surjective obtain rw


obtain simp aesop obtain simp aesop have obtain obtain simp obtain obtain simp have rw exact by_contra rw have simp lia


classical induction empty insert have rw resultant_mul_left


rw obtain obtain induction by_cases obtain by_cases obtain obtain rw simp conv_lhs rw roots_scaleRoots simp simp ring injective have apply rw simpa all_goals surjective obtain obtain obtain have simp_rw have simp_rw rw natDegree_eq_natDegree rw simp


rw wlog by_cases by_cases let let have obtain obtain have simp_rw have simp_rw rw this simp by_cases apply dsimp have rw resultant_C_mul_right] rw


induction induction mem obtain rw nontriviality rw simp one mul by_cases by_cases rw simp injective apply have rw simpa surjective obtain obtain obtain have simp_rw have simp_rw rw resultant_map_map, natDegree_taylor,


ext suffices simpa rw split_ifs exact suffices simpa rw split_ifs exact


by_cases obtain refine obtain exact simp intro suffices have obtain rw simpa rw simpa by_contra replace rw have simp lia


obtain obtain simpa have simp have rw isCoprime_mul_unit_left_left simp


rw let have have ext obtain obtain simp simp


rw let rw have ext fin_cases simp simp ring_nf


haveI by_cases rw refine rw intro have contradiction


ext simp smul_eq_mul] split_ifs subst exact exact rfl


ext trans rw cases inl inr rw apply simp intro cases inl inr cases inl inr simp rw


Polynomial.Splits.scaleRoots

cases rwa obtain simp obtain rw clear refine induction empty cons rw exact simp exact rw simpa


cases simp obtain simp obtain have conv_lhs rw rootMultiplicity_mul_X_sub_C_pow rw simp rw tauto simp rwa


rintro replace have rw have interval_cases have zero_ne_one rcases exact exact exact


by_cases rw exact have have rw apply rintro apply rw simp_rw map_one] replace replace rw rw exact


by_cases rw exact have have have rwa exact


cases rcases rw rw rcases let obtain haveI refine rw


symm calc congr rw congr rw mul_assoc, rw linarith rw congr rw iterate_derivative_X_pow_eq_smul, simp ring congr rw congr rw simp norm_cast rw rw simp


refine rw iterate_derivative_comp_one_sub_X] simp


let have le_antisymm have simpa coeff_eq_esymm_roots_of_card


Polynomial.fintypeSubtypeMonicDvd

set let have let let let refine rw exact


MvPolynomial.uniqueFactorizationMonoid

rw intro obtain iff_exists_prime_factors.1 exact let he rw


by_cases exact obtain have associated_mul_unit_right exact


set eval₂Hom have apply intro convert_to simp_all clear induction add mul_X induction add mul_X simp exact simp simp intro generalize change congr ext


classical trans simp obtain rw simp intro simp rw simp simp intro simp simp


letI subst ext dsimp rw obtain simp pderiv_inl_universalFactorizationMap_X, grind


cases exact letI rw simp map_one] congr rw congr ext ext rw rw


refine letI have letI let have obtain simpa refine apply_fun rw simpa have obtain simpa refine apply_fun rw simpa intro induction zero add tmul suffices refine induction add mul_X induction simpa add mul_X


cases exact cases dsimp cases dsimp letI letI refine change rw rw rfl


let have let jacobian_isUnit have simp simp infer_instance


let let have have rw let let let have refine trans simp rw simp rfl trans simp rw simp rfl


classical rw intro rw intro rw dsimp rw simp


conv_lhs congr congr ext rw rw convert rw simp


conv_lhs congr congr congr ext rw rw convert rw rw rwa


calc rw constructor apply exact rw rw exact apply exact rw rw exact


rw constructor rintro refine by_cases simp first exact exact simpa


rcases exact refine have rw rw nth_rewrite rw congr simp rw refine rw refine


PowerBasis.leftMulMatrix

cases rw refine simp_rw apply split_ifs simp_rw convert rw natDegree_minpolyGen, rw rfl intro rw apply


cases rw rw by_cases simp have rw apply exact rw refine rw rw congr rw


rw rintro rw rintro apply rw subst rfl exact


rw rintro rw rintro apply rw subst rfl rw exact


split_ifs rw simp refine rw have rw exact


convert constructor rw convert apply simpa


rcases simp induction zero succ have have rw simp have rcases by_contra rw simp norm_num rw conv move_mul conv rw conv ring exact decide


by_cases exact nontriviality rw use constructor rw exact rw exact


ext rw cases zero succ d simp rw show norm_cast


ext cases zero succ simp_rw catalanSeries_coeff,


PowerSeries.derivative.ext

ext cases zero succ have rwa smul_right_inj


ext induction zero succ have rw have rw rw have rw exact


ext simp apply rintro suffices a a congr rw refine rw symm rw norm_cast rw apply apply rintro apply rw


refine contrapose intro apply obtain calc have positivity


by_cases swap replace have exact nth_rw refine simpa simp refine rw


have intro simpa obtain refine eq_of_le_of_X_notMem_of_fg_of_isPrime rw intro rw replace refine obtain exact intro exact intro exact


refine swap have obtain exist_eq_span_eq_ncard_of_X_notMem refine rw exact


constructor exact intro by_cases have have lift exact obtain lift exact


refine by_cases exact obtain obtain simp obtain exact


rw simp split_ifs congr symm apply aesop aesop aesop aesop rintro obtain aesop rw rfl refine rintro simpa simpa


have rw constructor rw exact intro rw have have rw apply apply rw sub_eq_zero, rfl rw apply rw


refine refine have have exact refine le_order rw exact


suffices rw exact rw constructor intro rw rw exact intro rw


apply intro rintro by_cases rw by_cases rw rw exfalso apply rw


constructor intro rw apply simpa intro refine rw simp


split_ifs rw rw constructor simp rwa simp rw exact


suffices rw apply intro refine rw norm_cast lia


classical induction empty insert intro simp rw exact


classical rcases simp cases top coe have rw apply apply apply apply rw rintro have rw exact rw split_ifs simp rw simp


apply by_cases rcases rw apply rw exact intro rcases exact rw rw


simp_rw constructor rintro exact intro choose exact


rcases apply rw intro simp_rw obtain refine simp_rw intro contrapose exact


rcases apply refine simp_rw obtain apply suffices intro contrapose obtain rw refine apply


nontriviality simp_rw apply refine intro rw norm_cast exact


PowerSeries.IsRestricted.add

simp intro obtain obtain simp refine calc


simp_rw obtain rw use simp intro rcases right apply simp exact left calc


PowerSeries.IsRestricted.mul

obtain obtain simp simp intro obtain obtain refine obtain exists_norm_finset_sum_le obtain calc grw rw grind have rcases calc grw gcongr exact rw bound calc grw gcongr exact rw bound


rw rw simp have apply intro simp_all split simp_all simp simp_all constantCoeff_largeSchroderSeries, rw simp have apply intros have rw rw grind


ext by_cases aesop have simp rw show simp rw


cases zero succ have rw apply intro rw congr rw


ext rw split_ifs rw rw rw intro apply rw exact


induction zero succ rw set set set have set set set have trans simp_rw simp_rw rw nth_rw rw ring rw refine refine rw exact


suffices have ext refine rw exact rw exact intro induction zero succ rw have rcases rw refine rw refine simp_rw simp_rw rw replace rw intro rw refine rw refine rw refine simp_rw


rw split_ifs exact nontriviality rw exact


obtain set replace simp_rw rw rw coeff_map, exact rw rw rw refine contrapose rwa


induction zero succ ext rw simp_rw norm_cast rw


induction empty insert rw have rcases have have obtain rw exact simp rw exact simp


by_cases obtain refine have obtain have exact simpa


refine rintro have obtain have specialize rw exact


by_cases refine exact convert by_contra obtain exact


let have have refine refine rw exact rw exact


classical let have let have have have finite_of_isArtinianRing_of_isLocalRing exact


refine let have rw rintro exact have exact


let let let let let let let have have have have refine obtain have convert rw simp trans simp simp ring have have have have exact


Algebra.QuasiFiniteAt.baseChange

let simp let have replace refine obtain refine rw exact


have simpa have have have have have obtain have let refine obtain obtain obtain ext1 dsimp rw exact


obtain simp intro simp rw contrapose have exact


classical by_cases rw apply rw apply rw apply


constructor intro exact intro obtain exact


intro rw apply exact intro simp have rw exact exact rintro simp exact


classical obtain simp obtain simp nontriviality simp primeFactors_radical]


refine intro obtain trans apply apply rwa


induction zero succ rw refine intro rw exact intro rw exact


apply apply rintro exact intro rw apply rintro exact


refine cases exact by_contra have rcases apply rw exact exact rcases let let have rw let let let let have let let have rcases have rcases let map_smul x simp convert let to_res'.comp replace hx.trans let have let have intro absurd apply intro induction change apply change simp absurd let contrapose exact


have refine reg.of_isLocalizedModule rcases simpa


refine intro obtain h2.right_eq_zero_of_smul refine exact


induction nil ih conv congr rw top_toAddSubgroup, apply rw


induction nil refine refine rw cons let rw e.isWeaklyRegular_congr


induction nil apply any_goals all_goals cons ih specialize ih have have exact


obtain refine intro refine exact refine exact


let let refine refine rw congr let suffices apply ext1 dsimp simp


constructor introv apply exacts introv apply exacts


letI letI rw show colimit.isoColimitCocone_ι_inv dsimp apply exact


refine intro exact intro exact intro exact intro exact


classical have algebraMap apply simp obtain use simpa


introv letI letI let letI have have have rwa have exact


let have let have obtain have simp_rw rw replace rw replace rw obtain obtain use convert hx convert rw exact exact


classical obtain rsuffices exact clear induction empty insert simp rcases rcases apply simp rcases refine rw simp


apply apply intro let have haveI apply exact


obtain replace classical of we have apply intro have infer_instance obtain obtain choose choose let let have intro simp obtain simp rw rw simp rintro simp let have let have rw have apply rw apply simp simp_rw refine simp have apply simp exact have have obtain convert simp obtain simp rw simp_rw rw apply exact


introv algebraize replace intro simp_rw exact


let let have obtain obtain rw obtain use convert rw


obtain replace classical replace choose obtain let use rw rintro apply intro apply rw exact intro by_cases apply rw exact intro rw rw refine intro apply exact rw apply exact rw


apply exact introv rw suffices rfl infer_instance


RingHom.Flat.ofLocalizationSpanTarget

introv algebraize_only refine dsimp convert apply


RingHom.Flat.ofLocalizationPrime

introv algebraize_only rw apply intro algebraize_only have replace exact


introv letI change apply rintro letI haveI have obtain rw map_mul, obtain by_cases obtain exact refine have simp rw


constructor intro obtain exact intro use


intro choose rw refine inferInstance, haveI apply rw apply rw exact apply intro rw apply


classical intro rw obtain obtain rw refine inferInstance, rw intro have simp obtain let use simp intro let let have ext simp change simp rfl simp apply apply exact


intro simp obtain refine rw rintro letI have rw haveI apply intro simp haveI apply apply


apply introv obtain rw letI letI haveI haveI haveI intro simp haveI rw infer_instance refine inferInstance, rw intro convert_to simp rfl rw isLocalizedModule_iff_isBaseChange exact intro rw apply rw exact


introv obtain rw let let haveI inferInstanceAs haveI convert simp have letI haveI refine rw convert simp rw exact


introv obtain rw let let have haveI rw infer_instance haveI inferInstanceAs letI haveI refine rw convert simp rw apply exact


RingHom.Smooth.ofLocalizationSpanTarget

introv have algebraize refine rw simp exact


apply exact introv replace rw convert suffices rw convert infer_instance


refine classical introv induction zero tmul obtain rw add


introv rw letI intro apply intro obtain obtain rw obtain dsimp rw exact


intro algebraize rw intro let let letI have have exact


intro algebraize rw intro obtain simpa refine convert dsimp rw


rw simp constructor use simp simp have rintro field_simp norm_cast exact


have convert nth_rw push_cast ring_nf rw apply convert grind


have constructor rintro intro have obtain refine rw congr ring


rw have constructor intro obtain simpa refine rw congr ring rintro rw use simp


IsPrimitiveRoot.arg

rw obtain rw refine replace split_ifs exact convert rw split_ifs convert push_cast push_cast simp refine rw positivity refine rw exact rw convert push_cast rw exact push_cast rw exact simp field_simp constructor push_neg rify linear_combination rify linear_combination


intro have obtain obtain wlog simpa have obtain simp rw


have obtain have let refine obtain refine simpa


obtain rw refine exact nth_rewrite rw let rw exact simp rw


have rw replace apply_fun simpa card_range,


let obtain have refine exact let have refine apply apply exact exact refine apply exact exact push_cast have rw congr conv rw conv


have convert simp refine by_contra exact


rcases simp_all letI refine rw eval₂_eq_eval_map, exact


classical by_cases simp_all have by_contra set set have have have have have have rw refine have refine rw intro refine exact apply exact apply exact replace rw obtain rw have replace have rcases rw replace rw exact simp


revert refine intro congr simpa intro congr simp intro rw replace have haveI rw congr ring


by_cases have have intro obtain simp convert rw exact


by_cases subst rcases rw rw refine dvd_of_pow_eq_one rw mul_right_comm] simp


refine obtain obtain suffices rw rw apply rw


by_cases lift exact_mod_cast have lift rw apply rwa


IsPrimitiveRoot.neZero'

let refine obtain have have have refine rw


obtain have let have lift refine zify rw


constructor intro obtain rw exact rintro


obtain by_cases rw simp classical symm rw intro simp obtain rw simpa


have refine refine obtain exact obtain exact have obtain aesop


split_ifs obtain rw obtain push_neg simpa


obtain by_cases obtain by_cases exact rw exact suffices simpa


by_cases simp have symm refine simp rintro rw exact simp rintro exact simp intro rw rcases exact


ext suffices simpa constructor intro obtain exact rintro have rw rw


rw generalize_proofs refine rw congr rw conv rw exact


let obtain obtain have rw let have use contrapose specialize rw obtain rw obtain rw


have have have exists_ne_zero_of_sSup_eq_top have exact


cases zero ext apply simp succ rw ext simp


revert change revert apply intro intro let commutes obtain obtain replace conv_rhs rw exact


refine let constructor intro exact intro exact


Algebra.FormallySmooth.comp

refine obtain letI obtain apply_fun exact


rw constructor intro let rw e.toAlgHom.comp_algebraMap, intro let exact


refine letI haveI refine exact apply apply intro suffices rw


refine have intro apply convert simp let use apply refine ext simp


refine letI letI let refine intro change algebraMap congr refine rw use ext simp


classical let refine convert simp let have have have convert rw congr ext1 apply ext dsimp simp rfl


letI constructor intro ext change simp congr rw refine simpa


derivationQuotKerSq

letI refine rintro simp simp refine intro simp intro change intro obtain obtain change simp


let have have rw let let have ext obtain exact refine refine rintro obtain simp exact ext1 rw obtain exact ext rw apply simp exact intro ext simp intro ext simp


suffices exact letI have apply ext dsimp simp exact


constructor rw intro obtain have apply_fun simp rw simpa ext simpa intro obtain obtain rw exact


constructor intro ext1 exact intro obtain refine simpa map_eq_zero_iff


let let have have rw have rw refine exact


ext simp refine congr have exact trans have have exact have have exact


refine refine exact refine refine exact refine exact


choose refine refine simp_rw intro simp rw have map_injective rw obtain refine rw exact simp_rw simp have rw refine suffices apply simpa have map_injective obtain refine rw exact simp


classical fapply apply change rw have convert simp intro change simp ext change simp


classical cases constructor exact refine have refine rw exact obtain replace let let let have intro have rw obtain rw have intro let apply suffices rw intro obtain exact choose use ext ext simp obtain have have rw rw trans congr suffices by_cases subst rw have rw refine rw have rw simp rw replace rwa sub_eq_zero]


rw intro obtain rw rw have rw exact obtain have rw apply simp zero_mul, have ext simp apply have have rw have this exact change rw apply intro rw apply rw simpa exact


apply intro apply simp simp apply convert classical ext simp simp exact


nontriviality obtain choose let have have hb let have obtain let map map_inj have simp have apply intro simp let exact


refine nontriviality suffices rw refine simp


wlog obtain have apply rwa obtain have let refine refine rw exact obtain let let let let have ext trans simp simp have have obtain let let rw let refine rintro exact


ext rw constructor contrapose intro let have rcases rcases exact hd simp mul_inv_cancel₀ rintro exact


classical have obtain by_contra have have rw exact intro exact


constructor contrapose intro rcases exact rintro apply trivial


induction hgt change by_cases use rw by_cases rw exact have intro refine rw exact obtain obtain obtain use rw apply rw apply rw apply rwa


induction hgt change have by_cases rcases obtain apply use rwa by_cases use rw exact obtain have intro refine rw exact obtain obtain use rw refine rw apply rw apply rwa rintro


refine hf.polynomial_induction intro refine rw exact intro simp exact


classical set clear_value induction ind by_cases exact cases convert simp by_cases obtain by_cases e.1 exact obtain replace apply refine intro simp split_ifs rw exact exact simp use simp refine obtain have exact let obtain refine refine rw exact apply rw constructor intro simp refine simp rw simp show simp not_forall, intro refine rw intro rw refine intro simp intro replace simp not_true_eq_false, exact


set set have set set have unfold gcongr exact have unfold refine dsimp gcongr exact gcongr exact intro obtain obtain simp obtain obtain let simp have e₁.coeffSubmodule unfold rw simp congr change simp ext simp replace simp choose choose change rw choose choose change classical let let refine calc comap comap comap rw exact congr convert dsimp rw congr refine exact rw simp_rw congr apply dsimp rw exact exact rw preimage_comap_zeroLocus, swap simp simp simp zeroLocus_smul_of_isUnit convert rw rw simp_rw congr apply rw simp exact exact simp have simp preimage_comap_zeroLocus, simp simp rw simp refine norm_cast calc span unfold gcongr exact exact lia exact unfold gcongr exact lia


intro classical apply intro refine convert simp congr rw rintro exact suffices simp eq_compl_comm trans refine rintro by_cases exact exact ext simp intro let have have refine ext have rw refine by_cases subst rw rw isNilpotent_tensor_residueField_iff] simp simp intro cases use simp obtain refine rw intro let have dsimp gcongr rw split_ifs subst rfl refine change delta suffices by_cases gcongr exact refine exact refine simp split_ifs rintro exact exact rw refine refine rw apply have dsimp apply intro rw split_ifs subst rfl gcongr calc gcongr delta exact rw simp constructor apply rw exact intro rw split_ifs convert coeff_modByMonic_mem_pow_natDegree_mul rw intro simp have rw apply refine rw intro simp refine exact intro exact


classical choose refine simp simp intro have refine gcongr simpa refine simp delta by_cases have rw gcongr rwa


classical induction zero refine rw change rw rfl simp degBound_zero, exact succ let let have apply simp obtain trans gcongr simp by_cases rw simp rw simp exact simp gcongr exact let obtain chevalley_polynomialC simp e] obtain simp constructor intro simp exact simp replace simp intro exact let have refine refine refine simpa rw refine simp have obtain simp have intro change rw obtain exact simp change rw simp refine unfold rw change rw simp congr exact refine simp refine simp


classical let have let have have have let let have rw congr have simp simp refine obtain clear obtain simp_rw induction add obtain obtain refine mul_X obtain simp commAlgEquiv_X] refine exact add_mem simp obtain simpa have refine simp simp rw simp have simp simp obtain chevalley_mvPolynomialC intro obtain simp mem_degreesLE] constructor intro obtain simp simp refine simp split_ifs refine simp simp obtain simp exact refine simp exact refine rwa have rw simpa


refine induction isCompact_basis sdiff have refine simp congr ext simp union obtain obtain refine simp


obtain refine rw simp_rw congr let let trans rw rw zeroLocus_span]


apply refine intro obtain apply simp simp


intro let let rw rw letI have simp let exact


ext simp let have p.isPrime.ne_top let let letI have have have apply rintro rintro obtain refine rw exact letI have show simp have let have have inferInstanceAs have apply rintro rintro obtain refine rw exact rw rfl


refine have obtain refine rintro let have let let letI have letI have show simp have let have have inferInstanceAs have have simp


have intro ext obtain rw rw apply have have let have refine rw rintro obtain have exact


ext refine rw obtain exact ext refine rw exact rintro exact


simp_rw obtain simp_rw have contrapose simp_rw rw refine rintro exact


rw rintro simp obtain simp le_sInf_iff] contrapose rintro exact


refine rw conv_rhs simp_rw apply rw rintro change exact


tfae_have h obtain exact tfae_have h tfae_have rw suffices rw refine exact ext simp and_imp, constructor rintro rw exact intro apply obtain exact tfae_finish


by_cases exact let obtain sup_le let have have refine refine have simp_rw have refine simpa


let have obtain rw exact rw have have rwa exact


generalize induction zero use simp and_true, rw succ by_cases use have rw exact simpa obtain obtain hn have have exact


classical obtain have simpa funext_iff.mp refine rw simp apply simp intro have have simpa funext_iff.mp rw simp


cases have simp have rw rw simp rw simp_rw constructor intro replace simpa intro ext obtain simp rw obtain simpa simp


constructor rintro simp have rwa let have rw exact intro rw simp obtain have simp refine rw comap_comp_apply, ext exact


classical use ext rw isNilpotent_tensor_residueField_iff] simp


trans refine let rw change congr ext1 ext simp simp


intro obtain rw apply rintro obtain simp exact


classical trans refine let scalarRTensorAlgEquiv rw change congr ext simp simp simp


classical let smul_mem rintro refine simp_rw refine rw have rintro have simpa refine have rw exact


classical cases let have ext rw simp obtain let have intro convert ext by_cases subst simp have rwa exact


simp refine rintro exact have refine obtain exact ext rw refine rintro rw refine rwa


let refine obtain use ext rw simp obtain let exact


refine let refine rintro rw rintro obtain refine rintro apply rw exact have rw exact rwa


refine intro exact refine by_cases letI exact exact


rw apply rw trans simp_rw constructor rintro exact rintro exact simp_rw constructor simp_rw refine rw simpa simp_rw rintro exact


rw refine have replace rw have rw rwa exact


refine simp_rw preimage_comap_zeroLocus] constructor rintro refine rw rintro exact


PrimeSpectrum.primeSpectrumProdHomeo

refine refine rw simp exact simp_rw exact


apply rintro exact rintro rw obtain refine rw exact


rw ext simp constructor intro exact rintro exact


constructor intro have rw simp convert exact obtain exact intro obtain exact


cases refine obtain obtain simp have refine rw obtain have rw have rw constructor rintro rintro rw rw obtain have have refine rw exact rw exact refine rw


algebraize suffices nontriviality nontriviality constructor intro let have have rw rw suffices intro have exact obtain obtain refine refine have have rw have rw reflect_mul simp


rw image_antitone_setOf_maximal funext rfl


constructor contrapose rw simp_rw push_neg simp_rw exact intro exact


rw constructor rintro obtain obtain exact intro by_cases rw exact obtain rw rintro simpa exact


refine subset_antisymm intro contrapose simp intro obtain rw obtain obtain exact


classical obtain refine simp contrapose choose refine rw intro obtain rw exact


apply refine exact rw apply rw exact rintro rw let let set let let have rw apply refine rw exact exact


refine simp_rw intro obtain obtain exact


induction zero tmul obtain simp_rw refine rw mul_comm] add obtain obtain have refine rw mul_assoc,


RingHom.SurjectiveOnStalks.baseChange

let intro rw intro obtain refine intro simp id_apply, rw exact simp rw


refine obtain simp refine apply apply simp


apply rintro induction simp rw exact rw exact rw rintro exact


rw rintro induction zero tmul y convert_to simp exact add


classical let let let have let simp exact let simp exact set set have rw simp have have rw simp rw let let let let have simp apply simp use rw simp have simp exact have rfl have ext rw simp rw


classical obtain obtain have simp have obtain use constructor rw rw congr


induction zero tmul add obtain obtain refine rw rfl


classical obtain refine rintro induction zero tmul y rw exact add


obtain let have refine have simp have have have refine have rw congr ext simp


letI have have change convert_to ext exact


conv_lhs simp rw rw simp intro rw simp simp


classical let refine apply rw simp intro suffices simp ext simp


have let refine apply rw simp intro simp congr ext rw simp


apply let set have let let let let let suffices suffices simp apply suffices f.toLinearMap.comp simp ext simp simp


IsLocalizedModule.prodMap

letI letI rw apply rw infer_instance rw infer_instance


IsBaseChange.finsuppPow

classical apply of_equiv intro rw ext simp


MonoidAlgebra.tensorEquiv

refine tensorEquiv.invFun apply ext simp ext ext apply ext simp


MvPolynomial.rTensorAlgEquiv

apply simp apply rw exact intro erw simp rfl


haveI let let let let let algebraize_only letI exact


induction simp induction simp ext simp simp_all simp_all


have rw refine intro rw use rw exact apply


classical by_cases obtain letI letI rw rw congr ext simp rw intro exact


haveI haveI letI rw refine letI simp_rw intro simp


have let rw trace_eq_sum_embeddings_gen exact haveI exact


obtain have ext by_cases rw rintro exact by_cases lift rw obtain cases zero rw cases succ cases zero rw cases prime rw zero_mul, rw obtain cases zero obtain cases succ n rw rw intro have rw obtain cases rw have have rw exact positivity exact


ext rw sum_comm] congr rw congr rw simp rw ring_nf rw simp


ext rw traceMatrix] simp conv_lhs congr rfl ext rw rw congr conv_lhs congr rfl ext rw rw congr rw


suffices refine rw haveI let rw embeddingsMatrixReindex_eq_vandermonde, refine simp rintro exact rw


haveI let rw det_comm swap refine calc simpa


revert rw intro apply have congr_arg simp smul_eq_mul, rw simp rw apply intro simp ring


let let letI haveI haveI inferInstanceAs have p.primeCompl_le_nonZeroDivisors.trans haveI haveI rw simp haveI haveI have by_cases infer_instance have infer_instance haveI apply rw simp


induction nil cons simp rcases simpa simpa


constructor let exact rintro exact rintro exact rintro exact suffices refine exacts rintro


refine delta rw intro refine intro specialize rwa


have have refine rintro exact have have refine rintro exact let suffices rw refine simpa simp induction mem zero add neg


trans refine refine simp exact subset_mul_set refine rintro exact exact exact refine all_goals rintro exact exact exact refine simp


trans refine exact exact refine intro rw obtain exact rintro exact


classical intro induction empty intro exact have cons intro let hfg.dvd_iff_dvd_right.1 haveI rw exact


by_cases simp_all have apply apply exact


haveI refine intro rintro use have by_contra obtain apply refine rw mul_assoc] simp apply apply simp exact


Associates.unique'

apply apply intro refine exact exact have rwa


refine rintro refine obtain exact exact rw congr refine refine rw


by_cases simp refine obtain obtain rw exact


MulEquiv.uniqueFactorizationMonoid

have rw intro obtain hα ha convert simp exact let he rw


intro refine intros contradiction intro use constructor intro exact simp intro by_cases rcases obtain refine rw rw obtain refine intro rcases have contradiction exact


have intro simpa obtain obtain rw intro obtain replace replace simp


Associates.FactorSet.unique

unfold induction rfl rw rw congr rw apply intro obtain rwa


obtain rw rw have contrapose rw exact rw rel_associated_iff_map_eq_map] exact factors_unique


Associates.factors

classical intro apply have simp simp exact


by_cases simp_all obtain obtain rw rw exact


rcases exact obtain rw rw rw apply exact


have contrapose change rw exact rw obtain rw obtain refine rw exact apply apply apply apply apply apply


constructor intro refine rw exact contrapose intro obtain exact


by_cases simp by_cases simp rw rcases apply rw apply rw


nontriviality obtain rw have rintro have rw exact obtain use apply rw exact


nontriviality have have apply have convert symm rw intro rw by_cases rw rw


apply refine rw symm exact have rcases simp convert rw


classical nontriviality by_cases use rw apply refine apply rw apply rintro rw cases


haveI haveI haveI haveI refine simp constructor rintro change rw exact rintro have refine rwa obtain refine exact


classical obtain replace obtain rwa obtain exact


rcases exact refine rw intro rcases have exact


have rcases exact intro rcases have have rcases rw exact


refine have rw rcases obtain rw have have clear induction mem rcases exact exact one mul obtain obtain refine rw exact


have refine intro apply replace obtain obtain replace have convert rw


letI induction empty insert rw exact hcp is_coprime


letI have rintro exact by_cases rwa haveI letI refine rw refine apply apply


letI induction empty insert have have have have is_coprime rw hcp mul_left_comm


letI by_cases rw by_cases rw by_cases calc f haveI letI suffices f p f f obtain obtain rw mul_right_comm h1 congr rw simp_rw all_goals intro simp intro simp refine all_goals rintro rintro rw exact normalize_eq_normalize


obtain wellFounded_dvdNotUnit.has_min refine exact hm


rw revert induction zero succ intro constructor rintro rw rw singleton_add, apply rw rintro rw exact


apply apply rw le_count_iff_replicate_le] simp rw


classical by_cases simp apply convert exact exact


obtain prime_factors_irreducible have rw exact convert rwa


intro convert normalize_eq_normalize apply


rcases dsimp simp rw apply intro exfalso apply apply


have ext rw rw refine apply apply intro rcases exact rw exact


induction empty cons have have obtain rw haveI rw normalizedFactors_mul normalizedFactors_irreducible


constructor intro exact rintro obtain rw exact


cases obtain refine simpa simp simpa prime_factors_unique


constructor intro obtain exact intro obtain exact


constructor rintro simp normalizedFactors_pos, intro exact dvdNotUnit_of_dvd_of_not_dvd


cases obtain apply intro convert simp induction empty cons rw exact exact apply exact


constructor intros intro replace intro simpa constructor by_contra obtain apply ext1 let refine rw exact ext apply simpa


revert change revert apply intro intro apply apply ext replace dsimp rwa


have by_cases ext have rw infer_instance exact apply intro dsimp rw exact simpa exact ext rw intro rw exact


Algebra.FormallyUnramified.comp

rw intro have letI let let ext1 change congr exact


rw intro letI letI refine refine intro exact


rw intro letI haveI ext subsingleton exact


rw intro ext have have simp zero_add] rwa f₂).mul_right_eq_zero, sub_eq_zero]


have have have rw exact exact let let let have dsimp rw congr apply apply intro obtain suffices simp have rw exact have rw sub_self] have apply rw have obtain have rw exact rw refine have ext conv_rhs rw algebraMap_eq_smul_one] rw simp mul_one]


rw intro obtain change rw by_contra exact


constructor intro let have have rw suffices exact apply exact apply rw apply intro have generalize have have have have letI exact


classical have rw rank_zero_iff, infer_instance rw intro obtain have refine have rw obtain rw have have exact by_cases have let let have let have by_cases obtain exact have simp rw simp obtain have rw rintro rw cases use rw smul_smul,


rw have intro simp simp_rw constructor rintro refine intro obtain rw exact rw rw rintro use rw constructor suffices simpa exact simpa ht₂ apply simp intro use linear_combination


rw subst let conv_lhs simp conv_lhs simp have intro rw congr ext rw simp intro intro intros have simpa simp simp_rw apply intro apply exact simp forall_exists_index] simp exact


classical let let have let use conv_lhs congr simp constructor use rw rintro let b.repr let have intro simp simp trans refine simp intro rw simp let have apply apply apply suffices have intro simp_rw congr exact rw trans simp_rw rw rfl intro intro simp have intro apply exact rw simp smul_mul_assoc] apply apply apply apply use


ext simp trans induction zero tmul add rw


let have letI have have have have have have have have have rw nilradical_eq_zero] rwa


constructor have have rw refine obtain x).mp obtain simp replace induction zero mem add smul have simp


letI have letI have trans exact rw congr rw


classical cases constructor intro exact intro rw intro ext rw refine rintro have intro rw exact let have have rw apply convert rw have rw apply convert rw have trans rw rw let let apply simp rw intro let apply simp rw intro suffices have simp obtain apply_fun rwa apply rw ext rw simp exact


rw classical refine rintro simp intro obtain exact exact intro simp rintro simp simp


refine rcases have exact have have have rw exact


suffices intro wlog refine rwa rw apply calc v


constructor intro rw intro apply intro constructor intro rcases have rw apply simpa rw rw refine simp rw exact intro rcases have rw apply simpa rw rw refine simp rw exact


constructor intro rw rw intro by_cases simp constructor intro by_contra cases inl inr rw exact intro by_contra cases inl inr rw exact


constructor rintro let have have refine rcases simp rw rw simp linarith rintro rw rw intro obtain obtain exact


have by_cases by_cases exfalso refine rw exact rw rw rw exact rw refine contrapose have exact


apply by_contra have simp subset_singleton_iff, intro specialize aesop aesop simp_all have have simp_all


have set have apply rw exact rw obtain have rw rw simp have rw exact obtain use have set have simp refine rw exact have use rw mul_inv_cancel₀


apply intro rw apply intro by_cases simp obtain rw have replace simp


obtain rintro have simp specialize rw exact


have intro rw exact obtain obtain rw exact


suffices intro by_cases rw let obtain obtain by_cases rw refine simp rw rw rw exact


have let let have rw use constructor apply simp use simpa infer_instance


obtain obtain by_cases rw use rw rw obtain obtain replace rw map_inv₀, map_div₀, have have have zify rw zpow_add₀ rwa use simp mul_div_assoc congr rw congr rw apply rw exact


constructor exact obtain obtain refine rintro simp


rw refine rintro refine rw rw simp contrapose refine simp


constructor refine refine simp intro simp obtain exact obtain refine ext simp exact


rw constructor obtain refine ext simp constructor exact rw exact refine simp simp


intro set add_mem zero_mem smul_mem intro simp intro exact obtain simpa obtain simpa obtain exact


ext simp constructor rintro rcases rw exact rw exact intro rcases exact exact


nontriviality have constructor rintro by_cases rw obtain simp simp add_eq_zero_iff_eq_neg] apply_fun simp contrapose refine simp simp intro exact intro obtain exact


set by_contra obtain let have refine conv_rhs refine rw exact


let have obtain have have refine conv_rhs refine rw rw exact


intro refine by_contra have have isUnit_iff_exists_inv.mpr obtain have exact


suffices refine have let let have have have exact


suffices obtain obtain exact refine intro have have refine intro obtain obtain obtain refine exact exact intro refine rintro obtain obtain obtain apply exact


have have refine rw refine rw refine rintro exact


obtain exact let let let have hxR have have exact


obtain exact let let let have hxR have have have refine rw obtain exact


refine exact let suffices rintro obtain exact apply have refine rintro suffices apply apply convert simp


constructor rintro exact intro by_cases rw rw obtain exact refine intro contrapose obtain rcases simp_all rcases exact exact


rcases obtain obtain have have obtain right use rw field_simp simp left use rw field_simp simp


constructor by_cases exact obtain right intro obtain rw exact exfalso apply


constructor intro obtain have obtain exact exact intro suffices constructor intro by_cases by_cases replace replace obtain rw exact rw exact


classical refine obtain obtain obtain obtain rcases simp have rcases all_goals


have have have refine intro obtain by_cases refine have rw cases inl inr


haveI suffices constructor intro rcases obtain use obtain use


ext rintro rw exact simpa exact intro have replace refine simp change refine ext simp simp


constructor intro intro intro have simpa


constructor intro rw by_cases by_cases simp rcases have simpa have exact rintro apply_fun simpa


constructor intro by_cases by_cases rw simpa rw simpa intro by_contra


constructor rintro refine simp rintro rcases exact exact


constructor rintro induction mk have have by_cases exact exact rintro exact simpa


intro obtain obtain simp rw any_goals rw simpa


rw apply intro simp have rw gcongr exact exact


contrapose replace have rw use rw haveI exact


simp_rw refine rw use rw calc congr rw rw simp rw simp


apply simp induction h rw simp rw rw simp simp intro rw rw grind


WittVector.irreducible

have intro simpa refine obtain obtain obtain cases rcases rw apply_fun simp verschiebung_coeff_add_one, exact


obtain obtain rw have simp rw refine contrapose simp simp_rw convert ext1 rw


classical have by_contra apply ext simp let use refine exact


generalize rsuffices rw tsub_right_comm, have exact


rw refine intro rw simp have rw add_tsub_cancel_left, mul_right_comm mul_sub, eq_comm] simp apply intro rw rw clear rw mul_one, add_sub_cancel_right, apply intro rw rw rw simp apply apply rw simp rw simp rw push_cast linear_combination congr field


rw letI calc aeval aeval conv_rhs apply rw rw


have rw simp exact have rw rw exact exact rw apply rw exact


ext rcases simp frobeniusRotationCoeff] exact simp have simp convert apply intro simp rfl


intro have have have simpa rw simp convert simp simp


revert refine rintro have have obtain obtain let refine simpa exact


induction zero rw exact succ rw cases rw rw


induction zero succ rw cases zero succ rw simpa


have ghost_calc intro simp suffices wittPolynomial apply_fun simpa simp apply refine rw by_cases rw rwa


let haveI set have ext1 split_ifs rfl rw have ext1 split_ifs exact rfl calc simp split_ifs rw rw


ext1 apply rw replace simpa bind₁_X_right]


WittVector.IsPoly.ext

obtain obtain intros ext rw intro apply intro simp specialize simp apply simp convert all_goals simp apply ext1 apply simp


obtain obtain obtain refine bind₁ intros funext simp apply ext fin_cases


obtain refine intros simp apply ext fin_cases


obtain obtain intros ext rw intro apply intro simp specialize simp apply simp convert all_goals simp apply ext1 apply ext fin_cases rfl


haveI obtain have obtain rw obtain refine intro apply simp obtain replace use let let refine rw exact rw rw rw refine rw unfold rw simp simp congr linear_combination


rw refine rw intro apply refine apply have rw apply apply apply apply simpa


rw apply refine refine rw intro rw apply simpa apply exact


simp convert simp rw congr congr have rw simp exact simp simp


have rw conv_lhs arg rw conv_lhs arg rw conv_rhs enter rw conv_rhs enter rw simp rw simp apply ring


simp obtain let intro apply rintro apply let have refine obtain use intro dsimp rw congr ext obtain obtain fin_cases rfl


induction zero succ rw apply ext1 fin_cases simp simp


apply simp have apply_fun simp rw apply rintro rw simp


rcases simp have apply_fun conv_lhs simp rw simp rw rw intro rw rw have rw rw rw apply rw rw apply rw


induction h rw intro rw have map rw apply intro rw simp rfl simp coeff_map] rw rw swap revert exact


funext apply rw revert refine apply intro specialize apply_fun simpa intro


rw intro simp obtain obtain obtain rw replace grind


classical induction empty insert hind have refine ext exact congrArg replace simp have simp by_contra have push_neg choose have congrArg exact rw


rw intro rw rw let rw simp intro simp exact refine ext dsimp rw exact


apply intro split_ifs simp obtain rw simp rw calc apply funext simp exact


have intro refine rw exact rw simp simp intro apply rwa


induction ind rw neg_eq_zero, intro rw simp rw exact


induction ind rw insert_eq] on_goal simp intro rw apply on_goal all_goals intro replace rw rcases rw swap apply exact rw replace rw rw lia lia


induction ind rw show rw congr rw add_sub_assoc, apply intro rw rw


rw rw simp_rw rw rw simp rw simp obtain obtain use a b rw congr rw simp congr congr simp have calc rw calc


n have have exists_one_add_mul_pow_prime_pow_eq a apply obtain rw simp_rw rwa obtain rw simp rw exact


have have rcases rw infer_instance set have rw apply simp have rw exact obtain rw obtain have let have rw use rw rw apply rw simp


obtain simp obtain simp refine obtain rw have refine exact have rw rintro have have rw lia


classical have have let rw rintro simp_rw rcases simp simp


have obtain simp_rw exact have have by_cases exact refine have rw refine not_isCyclic_units_of_mul_coprime simpa contrapose conv_lhs rintro cases simp


by_cases rw by_cases rw by_cases rw by_cases rw simp rcases rw congr rw rintro contrapose cases apply rintro simp obtain rcases rw congr rw rintro contrapose cases rw rintro have simp obtain apply rw lia grind


Algebra.ZariskisMainProperty.trans

rw rw obtain obtain obtain refine simpa obtain obtain refine convert_to simp simp ring exact


induction zero succ apply apply rw exact


ext constructor rintro exact rintro obtain use rw rw


by_cases refine rw rcases have rw exact apply rw obtain simp intro simpa


induction succ isSuccPrelimit rw apply ext constructor refine simpa obtain rw exact


refine le_antisymm refine rcases classical letI haveI let let let f haveI suffices refine rcases rw refine have intro simp exact suffices refine apply rcases exact suffices rw apply rw apply


rcases rcases rcases rw exact rcases rw exact exact


rw refine rcases have rintro exact left rw use constructor rw exact rintro apply rw exact right by_cases exact have rintro apply rw exact left rw rcases contradiction contradiction rw rw norm_cast apply rw apply conv_rhs rw exact apply rintro rw all_goals


rw refine rcases left use rw apply intro exact right rw rcases norm_cast rw rintro rw rw


rcases have rw rw have rw intro apply apply rw apply rw rcases rcases rcases norm_cast apply


have refine have obtain obtain exact rw exact


cases obtain by_cases have hf simp have refine have obtain obtain exact rw obtain exact


rw induction fapply intro use refine apply rintro classical use apply constructor rintro dsimp by_cases rw cases exact rw cases intro have use dsimp rw congr suffices apply exact


trans refine apply use apply intro exact apply rw


refine refine use rintro apply dsimp refine rintro


cases rcases replace classical lift lift simp simp


cases exact apply obtain haveI rw rwa rwa


revert refine intro letI rw exact intro rw intro rw simp


refine rcases exact exact rcases exact exact


apply intro by_contra obtain simp_rw rw exact rintro exact


refine by_cases exact right by_cases exact right rw constructor rw exact rw exact rintro


constructor intro lift simpa rintro exact


rw constructor rintro exact rintro exact


classical simp constructor rintro exact rintro exact


rw rintro simp rcases exacts rintro exact


rw rintro apply refine rcases refine rwa


let let let suffices refine rw refine let aS⟩ rcases rcases change refine exact intro injection subst exact intro have let let have refine rw exact


refine rintro rw refine let rwa have simp_rw obtain refine rw apply rw exact rwa rcases let refine rwa rw rcases rw exact


apply refine change rw apply refine rcases simp rw simpa succ_ne_zero


suffices rcases exact rcases rcases let let haveI refine le_antisymm rw change rwa rw intro suffices rcases exact by_cases refine rw obtain refine by_contra exact rwa


refine rcases rw suffices rw apply have have rw simpa refine rcases exact have rw obtain rcases exact rw exact


rcases simp simp simp refine obtain have rw cases apply simpa rw rw rcases exact


rcases rw haveI rw constructor rintro exact have have apply have rw refine mk_iUnion_le_sum_mk.trans rw apply intro rw apply rw apply refine apply rw apply intro simpa


rcases simp have rcases apply conv_rhs apply intro rw exact refine rw exact intro simpa


by_contra simp_rw let refine rcases exact


rcases obtain apply have have rcases have let have have exact have exact have intro obtain exact calc


let suffices let have apply intro simpa intro simpa


induction induction simp_rw apply refine refine refine exact


refine rintro exact rcases exact rw obtain rw exact exact apply intro rw exact


refine rw exact rcases rcases wlog cases apply_assumption assumption all_goals left have rwa


refine rintro have rw rcases iterate lift exact


simp refine simp exact exact rcases rcases simp simp lift lift exact rcases have intro rw cases wlog apply rwa rwa exact


by_cases simp simp lift rw refine rintro have rw lift exact


rsuffices use rw rintro simpa rcases let classical apply rwa ncard_add_ncard_compl, exact


classical obtain have have simp_rw have have simp


classical rcases simp rcases rcases letI letI simp simp exact rw rcases rw rw simp rw apply letI exact letI exact rw rw exact


apply calc apply obtain exact inhabit exact


classical apply apply simp obtain simp exact rw exact apply exact simp


obtain obtain have classical obtain exact have exact


constructor intro exact rintro dsimp rw rw simp exact


Cardinal.liftInitialSeg

refine refine rw refine obtain replace refine apply rintro exact


have simp_rw intro rcases obtain have simp rcases calc


simp_rw rw apply lift_mk_le_lift_mk_of_surjective rw rintro obtain exact


refine simpa intro rw grw rw grw rw rintro cases rwa intro rw apply rw apply apply rintro grw simpa refine exact simpa


have by_contra apply rw exact mk_iUnion_le_sum_mk.trans_lt obtain refine rw exact


obtain refine rintro exact refine simp rfl rintro


have rw apply rw exact by_contra simp let let have rintro have rw apply obtain exact


have rw exact induction zero rw exact succ intro rw exact limit intro have rw exact bsup_lt_ord_of_isRegular.


classical rcases have exact set monotone set have have set have have set have have refine intro obtain obtain rw rw intro obtain rw exact refine simp split exact have have obtain exact grind


simp_rw contrapose refine rw exact obtain rw exact


ext by_cases obtain simp constructor cases rw simpa


cases constructor on_goal constructor exact convert on_goal rintro exact convert all_goals dsimp rw congr on_goal all_goals


SetTheory.PGame.inv'Zero

change refine apply apply simp dsimp infer_instance


SetTheory.PGame.inv'One

change have rw infer_instance refine apply apply simp infer_instance


constructor rw intro rcases left rwa right rwa rintro exact exact


constructor intro let rw rw exact rintro exact


induction h let let obtain simp_rw exact simp_rw convert exact let suffices rintro obtain refine apply obtain exact obtain exact refine suffices refine exact refine suffices refine exact convert change simpa


rw refine apply all_goals intro apply apply all_goals intro apply termination_by


rw refine rw exact rw exact rw exact termination_by


constructor refine wlog exact rw use simpa rintro exact


rw intro apply rw nim_add_fuzzy_zero_iff] exact rw obtain use rw exact termination_by


apply intro apply simpa simpa intro obtain let use simp let use simp termination_by


refine rw rcases rw apply apply rwa apply rwa apply rw exact exact termination_by


refine rw rcases rw le_sub_iff_add_le] refine lf_of_le_of_lf moveLeft_lf simp repeat rfl apply intro rw le_sub_iff_add_le] repeat simp_rw apply termination_by


induction mk constructor intro cases congr


induction mk intro rcases rw constructor all_goals rw refine rw apply apply


refine generalize obtain cases cases cases


Lists.inductionMut

suffices true, false, intro induction atom nil cons have exact


Lists.Equiv.trans

let suffices apply intro rwa intro obtain exact obtain exact obtain obtain apply intro rcases rcases exact intro rcases rcases exact rintro intro simpa


constructor obtain have rwa rfl have rwa rw apply rw exact rw exact termination_by


apply apply intro rw exact intro exact by_contra replace have rw exact termination_by


rw obtain obtain rw exact rw exact rw exact


apply apply all_goals intro obtain rw replace rw simpa apply intro obtain rw obtain apply simpa apply simpa


apply refine obtain rw on_goal on_goal all_goals abel_nf simp rw exact apply obtain have rw abel_nf simpa exact obtain exact have have rw add_ne_add_left abel_nf simpa obtain have rw abel_nf simpa exact obtain have have rw add_ne_add_left abel_nf simpa exact termination_by


apply obtain have apply assumption simp iterate rw abel_nf simpa obtain have apply assumption simp iterate rw abel_nf simpa termination_by


apply refine rw rw exact by_contra replace exact termination_by


have refine rw exact intro rw mul_one, add_assoc, exact refine apply replace rw obtain rw exact rw exact rw exact termination_by


Ordinal.boundedLimitRecOn

obtain induction zero succ have exact limit


suffices obtain exact intro rw have rw have refine rcases by_cases refine subst obtain exact exact refine obtain exact exact rcases rcases intro by_cases substs simpa subst simp obtain simp simpa


have obtain rw have apply rw apply rw gcongr rw exact grw


constructor by_cases rw right exact left rw apply suffices rwa rcases exact simpa


rcases simp have apply rw apply rw apply


refine obtain obtain apply exact_mod_cast


refine refine rw add_le_iff_of_isSuccLimit intro rcases grw exact rcases refine intro simp


rw refine rw simpa rw rwa rw exact rw exact


Ordinal.typein

refine rintro exact exact rintro exact refine rintro exact


refine let constructor rw exact obtain have have exact


rw constructor rintro exact rintro exact


replace cases nil cons cases nil cons intro suffices cases head tail exact


Ordinal.CNF.sorted

simp_rw refine rw exact rcases rw exact obtain rw exact rw refine rw rcases exact


ext obtain simp obtain apply rw simp rw apply rw simpa


ext let constructor rintro exact intro refine intro by_contra exact exact


refine trans refine have apply rintro exact exact exact


induction zero succ limit refine rw exact


by_cases by_cases induction zero succ limit exact


obtain obtain have rw exact obtain induction zero succ limit refine simpa


obtain obtain have by_cases obtain induction zero succ limit refine simpa


let have rcases refine simpa rw simpa rcases exact


rcases exact rcases rcases exact exact rwa


constructor rintro use rintro apply rwa rwa


rw constructor grw apply rw gcongr rw exact exact


simp_rw rcases exact rw refine exact_mod_cast


apply rintro exact exact all_goals apply rintro apply


refine by_contra have exact rintro rw exact


refine rw exact by_contra have have hf rw exact rw exact


induction zero rw exact succ rw exact limit have rw refine rw refine rw


apply rw intro rw exact apply intro rw exact


refine rw obtain rw exact have nth_rw rwa


rcases rw simp_rw exact apply apply rw rw exact


rcases rw exact refine rw rw rcases exact refine rwa obtain rw


apply apply rw gcongr dsimp obtain rw apply have rw have rw rwa


apply conv apply simp apply apply apply exact intro apply conv apply simp rw apply simp use


intro induction h rw apply simp le_sup_left, intro apply apply use apply simp exact


intro induction h rw apply simp forall_exists_index, constructor exact intro apply apply use exact


rw induction h apply conv apply simp forall_exists_index, apply intro by_cases rw apply simp exact rw exact


induction h rw apply simp intro simp cases inl let rw exact inr rw exact


apply have let exact have simpa lfpApprox_ord_mem_fixedPoint let exact


apply rw rintro obtain exact exact all_goals apply rintro refine apply_rules


unfold rw congr exact exact termination_by


rw convert rename_i cases exact termination_by


induction zero succ limit rw rintro exact


rw congr rw exact rw exact termination_by


rw convert ext refine simpa simpa termination_by


refine rw rcases have rw simp rwa nadd_left_comm have rw simp rwa nadd_lt_nadd_iff_left, nadd_left_comm nadd_assoc] rcases have rw simp rwa nadd_left_comm nadd_left_comm, rcases have rw simp rwa nadd_lt_nadd_iff_left, nadd_comm termination_by


refine rcases rcases refine have simp rw nadd_left_comm nadd_left_comm simpa have repeat assumption


apply rw intro repeat exact rw intro repeat exact termination_by


refine simp intro rw exact intro rcases simp rw rintro grw


rcases obtain rw injection simp infer_instance


intro unfold cases zero succ cases zero succ haveI simp


rcases have rcases haveI obtain rcases by_cases by_cases simp decide simp infer_instance simp have rcases infer_instance cases


subst have have rw refine apply intro have rw apply rw rcases grw gcongr exact exact exact grw simpa exact


intro haveI induction zero succ let let let change have by_cases simp simp have have have by_cases simp refine rcases rw apply rw exact refine rw have have apply simp gcongr rw have exact simpa exact lt_of_lt_of_le mul_le_mul_right calc congr have rw add_mul_of_isSuccLimit apply refine rw gcongr exact have rw simpa cases have simp rw apply rw gcongr simpa


rcases obtain obtain rcases by_cases have rw rcases obtain by_cases simp simp rw simp simpa rw exact haveI haveI obtain have have rcases obtain simp rcases simp simp rw simp opow_mul] rw congr rw exact


induction zero oadd rw rcases rw rcases rw rw rw simp lt_add_iff_pos_right, mul_add_one, decide exact have refine exists_lt_mul_omega0'⟩ rw gcongr apply have refine exists_lt_add rw gcongr apply refine rw gcongr apply rcases refine obtain exact rcases refine exists_lt_add obtain refine rwa refine have rw exact rcases simp exact exists_lt_add


Ordinal.Principal.sSup

have by_cases obtain assumption simp intro have exact rwa


intro rw obtain obtain obtain le_total use rw apply exact use rw apply exact


refine rcases exact rcases exact rw rw rw exact


refine induction zero rw rw succ rw rcases grw limit rcases apply intro calc a


rcases simp rw simp refine e.symm have have rw rcases rcases clear revert apply suffices induction zero succ


rcases rw exact rcases rw exact rw intro rw rcases rcases use rw exact


rcases replace rw exact refine dsimp rw exact


refine rcases convert apply rw exact rwa exact rcases dsimp rw rw exact


rcases exact rw obtain grw gcongr exacts rcases refine rw exact


obtain rw exact apply obtain grw conv_lhs grw


refine rcases exact rcases exact rcases simp exact rintro exact exact


apply have rw intro have have apply rw gcongr refine rw exact grw


obtain exact revert refine rw obtain rw obtain exacts


classical letI ext exact mem_range_rank_of_le


refine obtain have exact rcases rw exact rw exact exact


tfae_have simpa tfae_have h rcases simp refine exact tfae_have h tfae_have rintro have let classical refine simp split_ifs refine split_ifs refine tfae_have rintro exact tfae_have rintro exact tfae_finish


simp by_contra rw rcases rcases rw subst exact


have refine let suffices rw exact rw congr ext change rw rw suffices obtain rw apply by_contra apply rw exact


dsimp constructor rw intro constructor rintro obtain exact intro obtain use refine have rwa rw intro obtain obtain use exact


constructor intro have rw intro obtain obtain use refine exact intro rw intro by_cases have rintro rw specialize obtain exact have contrapose obtain use constructor exact intro have have rw subst exact obtain obtain use exact have have rintro obtain have simp_rw exact obtain obtain use refine rw exact


dsimp constructor intro have rw exact intro rw intro


rw apply ext rw use rintro obtain rw rw exact exact


rw refine rw apply suffices obtain exact induction nil cons obtain refine hb'.trans rw rw exact


obtain exact apply by_cases simp simp_rw exact apply rintro have rw exact


refine obtain rw have have aesop rw rintro simp convert


constructor rw refine conv_rhs rw veblen_invVeblen₁_invVeblen₂, simp aesop


simp constructor all_goals apply simp rintro have rintro simp rintro rfl simp congr exact


obtain obtain constructor rintro exacts rintro exacts


constructor obtain exact obtain exact obtain exact obtain exact


rcases right left exact left exact right right left exact right right right exact


rw constructor intro left rcases simp left use intro right rcases simp use


rw constructor intro left rcases simp use intro right rcases simp left use


rw constructor rw constructor intro rcases simp rcases rw left use rw simpa intro right rcases simp use apply


rw constructor apply rw constructor intro left rcases simp use intro rcases simp rcases rw right use rw simpa


refine numeric_rec ox refine rw exact exact exact exact


rw unfold rcases simp constructor simp simp exact simp


induction let have conv clear_value clear let refine rw simpa


induction zero succ constructor simpa exact


induction constructor rintro calc calc powHalf rcases rintro rintro apply swap exact calc powHalf grw simp apply calc rintro calc powHalf calc powHalf


induction zero succ hk rw mul_assoc] rw simpa


revert wlog intro intro obtain rw rcases rw simp_rw have norm_cast


obtain exact have exact mulOption_lt_iff_P1.2 rw exact


have have have have refine simp_rw intro rw constructor apply simp_rw apply simp apply rw apply all_goals cases rintro refine solve_by_elim


simp_rw refine all_goals rw simp first exact exact exact


have apply rw refine rw exact rw constructor rw apply rw apply


constructor have simp_rw convert rw rfl have simp_rw refine all_goals rw first rw rw exact


Surreal.Multiplication.main

apply intro replace cases rw exact have have have obtain obtain refine rw exact obtain obtain obtain constructor any_goals exacts


revert rw refine rintro refine have exact ih have exact rw exact


intro simp_rw obtain have rintro simpa have simp_rw refine simpa


refine simp_rw obtain obtain refine simpa


constructor revert apply intro by_cases exact obtain have have intro by_contra exact obtain exact cases rintro rfl exact


refine revert apply intro by_contra exact


refine obtain on_goal all_goals obtain exacts


refine all_goals obtain obtain exact obtain exact


apply simp_rw rintro simp simp apply exact exact


induction rw simp_rw apply rw rintro simpa simpa


rw constructor apply simp_rw rintro exact rw have exact termination_by


induction zero succ limit ih simp_rw vonNeumann_of_isSuccPrelimit apply rw apply refine rw exact rw by_contra refine rw refine exact


split_ifs subst exact apply apply exact exact


by_cases simp by_cases rw simp by_cases rw simp simpa


Mathlib.Tactic.ITauto.IProp.cmp

cases exact exact exact exact exact exact exacts


rintro have have use have have simp have simp rw simp


rintro have have refine have have simp simp have simp simp simp


simp intro absurd rify rw lia assumption


by_cases specialize simp contrapose apply_fun simp suffices obtain have rw intro apply_fun rw rw exact have apply_fun simp cases lia assumption rw apply use exact simp existsAndEq, tauto use ext apply_fun simp rw apply rwa


by_cases subst contrapose simp subst use simp by_contra rw set set obtain rw specialize simp rw rotate_left simpa simp replace qify assumption apply conv apply apply apply apply simpa


by_cases apply rcases have rwa contrapose rw positivity


have by_contra simp simp lia rcases rcases rw have simp rfl have simp rfl rw refine simp apply apply apply positivity


refine jacobiSym.eq_zero_iff.mpr have change rw exact


have simp decide rcases rw haveI rwa jacobiSym.legendreSym.to_jacobiSym,


have obtain contradiction rcases simp_all exact


rw refine rw exact rcases exact rcases refine have rw norm_num exact exact


let let have apply rw simp use intro simp by_cases simp generalize_proofs rw conv_lhs have li.pairwise_mergeSort rw refine contrapose exact simpa


induction nil cons refine subst suffices induction nil cons


dsimp congr induction nil cons rcases by_cases simp rw simp symm simp


induction nil cons cases simp getElem_cons_zero, subst cases cases simp cases cases obtain simp rw apply apply


simp cases none dsimp rw some have replace dsimp induction nil cons rcases cases dsimp rw subst simp obtain obtain have specialize simp suffices rw simp rcases apply simp rwa


intro by_cases rw obtain obtain suffices have rw rw apply symm rw rw rw obtain exact rw rw contradiction rw rw contradiction rwa


Plausible.InjectiveFunction.injective

obtain generalize generalize dsimp have rw induction nil cons xs_ih simp exact revert rw apply rwa rwa


refine have continuous_algebraMap simp exact


unfold apply refine simp_rw have filter_upwards simp rw apply have tendsto_fst.prodMk simpa apply simp


rw intro rw have filter_upwards simp rw apply have simpa


apply have eta_expand simp_rw nth_rw simp grind rw exact


refine have rw rw obtain rw obtain rw refine rw apply rw filter_upwards rw exact


ext rw asymptoticNhds_eq_smul, apply filter_upwards refine specialize rwa


rw map_prod_eq_map₂, refine have filter_upwards apply simp_rw rw exact


apply intro dsimp apply intro rw refine convert ext simp nth_rw exact


apply rintro simp_rw rcases let have have rw exact let rcases use refine rw apply intro let rw change rw exact


obtain let have choose refine inter_mem obtain by_contra rw let exact


letI set rw let have rintro change have obtain obtain let have choose let let let let have refine exact have f_op.image_mem_nhds refine rintro by_cases exact rintro simp exact


rintro have refine simp refine all_goals


have refine rw rw have intro refine rw rw simp_rw exact


apply intro exact intro rcases filter_upwards rintro calc


GroupFilterBasis.isTopologicalGroup

letI have have refine rw suffices intro rcases refine intro exact rw intro simpa intro rw rfl intro rw intro exact