classical obtain convert refine by_contra obtain simpa simp obtain hrirred simpa obtain obtain replace rw replace rw have rwa have simp rw refine simpa specialize simpa simp obtain obtain simp obtain simp


refine have induction zero tmul use calc u add obtain obtain exact obtain obtain aesop


refine let rcases rwa have refine induction zero add tmul obtain obtain obtain use trans simp simp have rw cases


ext constructor rintro simp use rintro simp use simp use


induction mem induction mem zero mul add smul zero mul add smul


apply intro induction mem add zero mul hpy apply exact exact exact exact exact smul apply change exact


NonUnitalSubalgebra.iSupLift

subst exact let simp rw rfl) map_zero dsimp exact map_mul dsimp apply all_goals map_add dsimp apply all_goals map_smul dsimp apply all_goals


apply simp_rw refine rw change exact refine rw exact


classical obtain obtain use have have assumption


induction zero rw obtain exact succ revert simp_rw exact


ext simp constructor rintro exact rintro refine obtain convert apply rw


by_cases rw simp rw have simp simp have simpa rw simp


ext have nth_rw rw constructor exact rintro simpa


have refine calc noncomm_ring calc noncomm_ring have rw simpa smul_mul_assoc]


suffices refine apply simp intro rw contrapose simpa


constructor rintro exact rintro refine all_goals apply assumption


rw congr simpa spectrum.setOf_isUnit_inter_mul_comm rw all_goals


classical ext constructor intro rw let obtain refine rw intro suffices specialize simp refine simp rw sum_of_support_subset simpa rintro rw rintro induction zero tmul add


have apply_fun convert ext simpa ext simp constructor rintro exact rintro refine rw


Subalgebra.iSupLift

let intro rcases simp let map_one dsimp exact map_zero dsimp exact map_mul dsimp apply all_goals map_add dsimp apply all_goals commutes dsimp exact exact


have rw congr exact rw congr rw rintro obtain simp exact


induction mem induction mem algebraMap mul add algebraMap induction mem algebraMap mul add mul add


refine eq_top_iff.2 exact exact exact exact


apply intro rcases clear induction nil cons rw rw refine replace clear suffices rcases rw exact induction nil cons rw rcases rw rcases refine rw exact refine change exact


induction mem algebraMap r have convert rw exact add mul


apply intro rw obtain replace rw exact rw apply rw exact


suffices obtain exact choose let let have ext change simpa have rw apply intro exact let have apply rintro change rw refine exact


refine rintro refine rcases rw exact rw exact rw exact have rwa isIdempotentElem_toSubmodule,


rcases haveI nontriviality letI letI haveI rw change rw


refine induction inl_add_inr a simp_rw rw by_cases ext simp simpa exact


Equiv.algEquiv

intros exact commutes apply simp algebraMap_def]


intro induction inl_add_inr obtain exact


rw choose refine rw suffices this.countable_of_injOn rintro exact


ext apply intro simp stdBasis_eq_single, ext simp


Associated.prod

induction empty simp rfl insert classical convert_to grind


obtain induction empty apply push simp left cons simp simp simp obtain rcases refine simp refine multiset_prod_mem left left rw left rcases rw refine right rw exact rw refine rw exact


induction empty cons rw obtain gcongr refine induct have have have refine have have rw exact


induction zero succ simp split_ifs simp simp


ext refine simp intro simp rw rcases rw simp lia rw partialProd_succ, simp lia rw simp lia


rcases rwa assumption rw exact rwa partialProd_right_inv, simp rw exact rwa partialProd_succ, exact rw exact


induction zero succ rcases rw unfold simp finCongr_apply, by_cases conv simpa replace subst conv simp rfl


induction zero succ by_cases have rw have ext simp rw simp have rw have rw have intro have simp simp


have rw exact have rw exact rw simp congr


set change have rw intro exact rw refine contrapose exact


classical by_cases have have unfold rw refine rw unfold rw rwa


classical rw have intro rw grind rw by_cases apply rw rw apply


have rw intro simp contrapose rw rw refine intro simp exact


classical refine have obtain obtain rw simp_all use ext by_cases rw simpa rintro rw exact


classical refine simp intro simp intro rw rw intro exact


haveI exact rw apply exact rw apply exact rw exact prod_const_one


classical calc grind solve_by_elim intro refine obtain exact solve_by_elim


induction nil cons simp by_cases rw mul_assoc, congr refine rw rw grind


classical induction obtain simp have suffices rw cases inl inr suffices ih grind


intro classical by_cases rw rw rw exact exact


classical let have rw swap intro have have simp exact exact


classical have simp exact rw mul_prod_erase


set symm apply exact intro rw apply intro obtain exact simp


induction empty cons ext rw classical rw exact


split_ifs rw intro rw exact simp rw grind


split_ifs obtain rw exact push_neg rw exact


induction nil cons obtain simp rw mul_assoc,


induction nil cons specialize rw simp split_ifs rw rw


induction nil cons simp rw clear by_cases simp simp prod_cons,


induction nil cons simp rw clear by_cases simp mul_inv_cancel_left, simp


induction nil cons by_cases simp rw simp exact


refine apply intro exact intros apply intro rw


induction nil cons simp_rw congr refine by_cases simp simp true false simp by_cases refine simp exact


induction empty cons rw by_cases simp have exact


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


have rw simp have rw rw conv simp_rw conv_lhs have intro rw abel simp_rw abel


rw split_ifs rw congr simp exact obtain exact


classical induction empty insert ih have intro simp rintro have rw exact rw refine have rw refine rw simp congr congr exact exact simpa ha


classical calc sum_bij simp prod_attach] congr simp tauto)


refine clear intro have rw add_mul, congr rw congr rw exact rw refine rw exact


refine simp simp sum_map_add, mul_assoc, exact


classical let rw rw exact have rw refine simpa rw suffices congr_arg intro simpa


IsBrauerEquivalent.trans

obtain obtain exact compAlgEquiv iso1.mapMatrix compAlgEquiv reindexAlgEquiv compAlgEquiv iso2.mapMatrix.trans


AlgCat.HasLimits.limitConeIsLimit

refine congr ext simp intro ext simp apply ext simp apply intro ext simp apply intro simp apply apply ext exact


instEssentiallySmallFGAlgCat

suffices exact rw refine let refine simp obtain exact refine obtain obtain let refine ext obtain exact


induction zero rw rfl succ rw nth_rw rw rfl


apply exact preserves hf let let have simp limit.cone, iY] ext change simp change simp suffices suffices rw simp_rw refine funext exact


AddCommGrpCat.Colimits.Quot.desc

refine dsimp rw intro rw simp change rw simp


AddCommGrpCat.Colimits.quotToQuotUlift

refine rw intro obtain rw change rw dsimp rw


specialize ext1 simp rw exact replace rwa


GrpCat.SurjectiveOfEpiAuxs.agree

refine rintro change ext rw by_cases rw change simp rw simp rw have change dsimp simp have exact


refine change rw refine apply apply refine ext rw exact set ι naturality u ext dsimp rw use refine dsimp rw change rw dsimp rw


letI letI refine erw cat_disch) dsimp have simp erw erw cat_disch


apply letI ext apply intro change have simp


intro have rw obtain let have rw simp rw simp obtain have rw obtain rw rw simp have ext rw apply rw use rw rw use rw


ModuleCat.HasLimits.limitConeIsLimit

refine intro simp rw rfl intro simp rw rfl


ModuleCat.instMonoidalPreadditive

refine intros ext refine simp erw simp intros ext refine simp erw simp intros ext refine simp erw erw simp intros ext refine simp erw erw simp


ModuleCat.instMonoidalLinear

refine intros ext refine simp erw simp intros ext refine simp erw simp


apply apply exact exact intro rw erw rfl


intro let let let let let let have have have have have rw have dsimp erw have have dsimp erw exact


let have refine all_goals apply rintro rw map_smul_eq


let have apply all_goals apply rintro rw map_smul_eq map_smul_eq


MonCat.Colimits.descFun

fapply exact intro induction refl symm trans map mul one mul_1 mul_2 mul_assoc one_mul mul_one


obtain obtain replace obtain apply use simp_rw hfg]


obtain obtain simp obtain apply use dsimp simp_rw hfg]


apply intro have refine π refine intro refine ofHom map_mul intro simp forget_map, congr simp rfl exact


CommRingCat.pushoutCocone

fapply exact exact exact ext trans exact exact


apply intro refine ext ext have replace rw exact


CommRingCat.equalizerForkIsLimit

fapply intro use constructor ext rfl intro ext exact


constructor rintro have apply conv_rhs rw rw exact


have rw rw rw limit.isoLimitCone_hom_π change infer_instance


have limit.isoLimitCone_inv_π dsimp rw have infer_instance


CommRingCat.pullbackConeIsLimit

fapply intro refine intro exact intro ext rfl intro ext rfl intro refine change have have rw rfl


simp_rw constructor intro have simp exact refine letI let let ext simpa


CommRingCat.FilteredColimits.nontrivial

classical cases exact have refine have obtain exact


classical have choose let let right fst snd obtain refine ext1 apply rw simp intro rw have simp


SemiRingCat.HasLimits.limitConeIsLimit

refine simp rfl intro simp rw rfl simp rfl intro simp rw rfl


refine have isClosed_iInter convert ext simp constructor rintro exact simp


haveI out show simp rintro exact refine have rw simp obtain exact


intro simp obtain intro induction zero tmul add


have have constructor rintro rcases have rintro rw nth_rw exact have apply_fun apply_fun rw norm_cast exact intro rcases apply_fun push_cast rw exact


refine h.trans by_contra rcases have rw rcases apply_fun rw exact


wlog simpa obtain rw constructor simp intro have simpa


apply intro let haveI let let rcases let have have have rw have by_contra rw rw have rw have exact have rw have have absurd exact haveI haveI haveI have exact


constructor intro exact intro rcases rcases let have have simp apply exact have apply have exact


constructor intro rcases rcases use constructor exact cases intro convert have rw convert symm apply exact intro use exact


intro constructor intro contrapose refine simpa simpa


intro suffices cases intro cases zero succ have exact


constructor intro haveI apply intro apply exact


cases intro by_cases rw haveI exact exact


intro rcases let max exists intro let rcases have have rw exact let let have suffices have haveI succ_nth_fib_le_of_nth_den have haveI succ_nth_fib_le_of_nth_den have have have suffices calc gcongr calc


cases zero have rw exact succ rcases rw exact


suffices obtain have intro simp have simpa rwa exact


obtain exists_s_b_of_partDen obtain rw exact


let induction zero succ rcases rcases simp have simp calc


let rcases have have have rw obtain have calc g.dens


let let set set change obtain have of_partNum_eq_one have simp conts_eq.symm, let obtain obtain let conts.b suffices grind have have rwa have haveI fib_le_of_contsAux_b have suffices have suffices have have haveI haveI fib_le_of_contsAux_b le_trans have haveI inv_pos.2 positivity rw rwa suffices constructor have solve_by_elim suffices suffices have gcongr


have refine rcases simp apply have apply_rules conv_rhs gcongr exact


induction zero contradiction succ let change obtain cases zero succ have have rw exact simpa


induction zero succ rw cases none some obtain rcases simp replace have have simpa


obtain succ_nth_stream_eq_some_iff.mp have cases rw obtain have exact


induction zero intro have simp succ intro suffices rw solve_by_elim rcases have exact


let rcases use have stream_nth_fr_num_le_fr_num_sub_n_rat have have simp sub_self, have have lia


induction zero have rw succ rcases rw rw obtain rw rcases rw rw


rcases obtain rw floor_intCast] rw exact


cases none cases simp some gp_succ_succ_n obtain s.ge_stable ext1 rcases simp cases simp simp


cases none some induction zero obtain have squashSeq_nth_of_not_terminated simp_all succ obtain suffices simpa have simp_all


cases zero change simp succ cases simp exact


rcases have simp obtain have cases zero suffices simpa conts_recurrenceAux grind succ n obtain let set set let let let let set set let let let let have have rw rw have have contsAux_recurrence rw rw suffices obtain simp symm simpa grind


induction zero succ let suffices rcases have rw intro exact suffices rwa intro rcases obtain obtain suffices have squashSeq_nth_of_not_terminated grind have refine refine have exact refine exact have intro obtain exact exact


induction zero succ let let set set let let let let change have obtain suffices simp have rw ring suffices exact


change induction zero succ cases none some gp_head have have rw simp


rw iterate dsimp split_ifs subst rw rfl rw rfl


classical rw apply swap simp_rw exact simp_rw split_ifs rfl rw


classical rw apply swap simp_rw exact rw exact


classical rw apply obtain by_contra obtain apply all_goals


ext simp by_cases let replace exact suffices simpa


have suffices classical have have simp intro have have replace restrict_commute have rw


refine let have let suffices rw exact ext change rw


change mulHom rw dsimp rw apply simp_rw funext simp


DualNumber.lift

refine exact show rw show rw invFun show rw left_inv right_inv show


induction rw refine unfold dsimp rw mul_assoc,


rw by_cases rw rw rwa rcases suffices obtain use generalize subst rw rw simp rw apply rw gcongr apply rw gcongr apply


constructor intro rw apply intro by_cases rw exact rcases generalize subst rw rw rintro rw rw


rcases rcases obtain obtain rw mul_div_cancel_left₀


replace replace dsimp constructor intro obtain constructor intro obtain exact rintro obtain rw exact intro constructor intro obtain obtain exact rintro apply simp


Function.Exact.splitSurjectiveEquiv

refine invFun left_inv right_inv have have constructor intro simp suffices simpa intro obtain exact have have constructor ext rw ext rw intro rintro ext1 apply ext apply ext


Function.Exact.splitInjectiveEquiv

refine invFun left_inv right_inv have have constructor intro simp obtain suffices rw rintro obtain refine have have constructor rw ext ext rw intro rintro ext


simp constructor intro simpa intro obtain simpa


have have have have rw rw simp mul_one, rw


Equiv.divisionRing

let let let let let let let let let let apply


Equiv.field

let let let let let let let let let let let apply


intro obtain obtain obtain obtain use simp


rw intro obtain suffices simp obtain obtain rw apply subst rw


FreeAlgebra.induction

let mul_mem add_mem algebraMap_mem let have ext simp suffices rw exact simp exact


set refine induction grade0 add mul grade1


constructor intro rcases induction one have simp mul_of simp use have simp rw exact intro induction one mul_of specialize rcases rcases use rfl


nontriviality rcases refine suffices simpa calc a


obtain simp obtain apply rw gcongr exact dvd_gcd exact


obtain replace rw have apply have exact have exact


by_cases rw rcases exact induction zero succ rw trans exact exact


have apply trans exact apply apply apply grw have use rw exact rw have apply rw have intro rw apply exact


cases use rw by_cases use obtain simp rw by_cases use rw apply rw exact obtain use rw use rw have rw exact obtain use obtain rw rw obtain rw have apply rw apply rw rw use rw


by_cases obtain simp_rw exact obtain obtain exact


by_cases rcases simp obtain have rw dvd_gcd_iff,


apply refine rcases rcases rcases use rw rcases rcases rcases use rw


rw constructor intro apply simp use simp intro rw rcases apply


classical trans rw rw refine exact refine simp intro rw split_ifs simp


classical by_cases refine rw choose refine simp rw


classical revert refine simp intro rw gcd_assoc, exact


constructor intro apply rw apply refine simp intro simp


classical by_cases use rw dedup_nsmul exact choose refine rw conv_lhs congr rw


obtain obtain simp ext simp mul_inv_rev,


rcases rcases by_cases simp_all have intro rw apply have have have have exact


refine rcases exact exact rintro exact exact


constructor rintro obtain exact rw exact rintro exact exact


simp constructor rintro exact rintro use


simp apply constructor rintro exact rintro simpa


simp refine constructor rintro refine simpa rintro use


constructor rintro apply apply rcases refine contrapose rcases simp


induction zero succ refine rw rcases rw rcases refine rw obtain exact


obtain exact obtain obtain refine conv_lhs


by_cases simp by_cases simp by_cases subst simp rw exact


constructor rintro exact rcases refine rintro simp


constructor intro rw intro apply have rw exact rwa apply apply


rw contrapose constructor rintro refine rwa rwa refine rw


ext simp mem_valueMonoid_iff, constructor rintro simp rintro refine simpa


refine simp induction mem obtain exact one mul obtain obtain refine simpa inv obtain exact have let have let have rw_mod_cast rw apply apply use apply use


by_cases simp by_cases subst simp simp have rw exact


simp refine obtain induction grind obtain use simp


constructor rintro obtain exact rintro exact


constructor rintro obtain exact rintro have exact


induction zero succ rw exact pred rw exact


have intro obtain exact rw obtain rw rw obtain exact rw


unfold generalize replace induction zero one bit rw cases rw


Monoid.ext

have have let have ext exact rcases congr


DivInvMonoid.ext

have have let have ext exact have ext exact rcases congr


cases simp split_ifs simp rw conv_rhs rw rwa


rcases exact constructor contrapose intro obtain simpa intro rw simp obtain have simp_rw rw


cases simp simp rw sub_eq_iff_eq_add] simp


suffices refine rwa have rw refine rw exact


classical refine convert have apply simp_all


have rw have convert simp rw congr have rw


induction zero succ ih have ext simp rw exact


induction zero succ have ext simp simp_rw simpa sum_eq_zero


obtain simp use toFun map_one map_mul simp_rw rintro exact simpa


obtain obtain have rw aesop exact map_mul invFun left_inv right_inv


let smul_mem y rintro exact simpa suffices refine rintro exact


induction zero succ pred rw norm_cast simp rintro


suffices apply replace rw image_comp simpa clear rintro refine replace specialize aesop


refine rintro by_contra let let have clear obtain have have exact have obtain grind have have replace exact


rw refine have rw refine simp let have rw simp have rw refine simp


have intro by_contra rcases suffices simp exact suffices simp exact


refine suffices refine rcases rcases right simpa


wlog rcases simpa this suffices refine rcases rcases simpa


constructor refine rwa rwa rintro rwa rwa


refine rw rcases rcases use apply rw add_assoc,


rw constructor rintro use rw exact rintro use rwa m.toNat_sub_toNat_neg]


simp_rw simp_rw constructor rintro refine rw refine refine lia rw rintro rw exact


constructor contrapose rintro exact simp rintro exact


constructor rintro obtain refine rw exact rintro exact


refine have obtain obtain have refine exact exact rintro rw


classical induction empty simp_rw exact insert rw simp_rw simp_rw constructor rintro refine intro obtain rwa rw exact rw rintro exact


Set.decidableMemPow

induction zero simp infer_instance succ rw infer_instance


have rcases refine rw have refine rintro exact have monotone_nat_of_le_succ refine le_antisymm replace have refine exact convert rw intro rwa


induction simp and_left_comm, constructor rintro exact rintro exact


suffices change rw simpa apply constructor suffices exact change apply apply


obtain have rintro exact have rintro refine have rwa simp rw rw grw refine rw simp mem_comap] exact


haveI exact have have let conj_injective


classical induction mem one mul obtain use rw simp simp inv obtain use rw simp simp


induction mem induction mem one mul inv one mul inv


refine intro rw exact exact rintro exact rintro exact


refine suffices simpa refine simp exact rintro rcases exact rintro exact apply simp


have rw simp simp rw intro simp intro refine simp exact


constructor intro refine rintro exact exact exact rintro exact rintro exact rintro


refine refine closure_induction rwa simp


revert simp_rw intro induction one mul_left cases inl inr


rw induction one mem obtain exact inv_mem obtain exact mul


suffices refine exact exact rintro exact


rw refine induction one mem inv_mem obtain simpa mul_mem_mul mul obtain obtain refine exact simp


ext simp constructor rintro refine exact rintro refine suffices exact


induction mem induction mem one mul one mul


apply intro induction mem one mul push obtain all_goals exact rintro exact exact


induction empty have exact insert ih have ext by_cases subst simp simp rw clear apply by_cases subst simp simpa have simp exact


classical induction mem one mul obtain use rw simp simp


refine suffices simpa refine simp exact rintro rcases exact apply simp


simp_rw obtain induction one mul_of simp refine simp


constructor intro constructor rintro exact rintro exact rintro exact


constructor intro constructor rintro apply exact rintro apply exact rintro have apply simpa have apply simpa simpa


induction mem one mul obtain use rw exact


refine suffices simpa refine simp rintro rcases exact apply simp


have rw simp simp rw intro simp intro refine simp


Prod.instTwoUniqueProds

have exact refine of_injective_mulHom apply exacts exact


rw congr ext simp rw set by_cases by_cases rw simp congr rw by_cases have rw ιOrZero_eq rw zero_comp, rw by_cases have rw ιOrZero_eq rw zero_comp, rw trans simp congr by_cases rw dsimp intro apply rw rw by_cases rw dsimp intro apply rw rw rw intro apply have rw exact intro apply have rw exact


rw rw congr apply intro simp rw mapBifunctor.ι_D₂] set by_cases by_cases rw congr rw by_cases rw ιOrZero_eq dsimp rw ι_eq] rw zero_comp, rw by_cases rw rw dsimp rw ι_eq] rw zero_comp, rw trans simp congr by_cases rw intro apply rw dsimp rw rw by_cases rw intro apply rw dsimp rw rw rw trans simp congr rw intro apply simpa rw intro apply simpa


ext rw by_cases have dsimp rw ιOrZero_mapBifunctorAssociatorX_hom, rw comp_zero,


ext rw by_cases have dsimp rw assoc, rw comp_zero,


ext dsimp rw by_cases rw intro apply rw exact dsimp rw


ext1 dsimp rw smul_left_cancel_iff, congr ext dsimp simp


constructor rintro refine exact e rintro refine isomorphic_distinguished exact


dsimp simp constructor intro exact intro obtain refine exact suffices from constructor intro rw have have apply


have inferInstance exact small_of_injective φ


letI have let have ext dsimp apply apply symm apply rw exact


let let have have apply all_goals simp congr dsimp rw dsimp rw dsimp rw dsimp rw


letI simp constructor intro exact intro lift exact


let let have rw dsimp rw dsimp rw exact retraction mkHomToSingle rintro apply id apply rw


obtain have rw exact have rw have apply apply rw


letI have rw intro induction zero rw infer_instance succ let have have exact


let let have rw dsimp rw dsimp rw cyclesMap_i] exact section_ mkHomFromSingle rintro apply id apply rw rfl


change dsimp erw rw dsimp rw singleFunctorsPostcompQIso_inv_hom, simp unfold rw rfl


have rw congr dsimp simp congr change simp congr dsimp simp exact


letI obtain obtain simp exact small_of_injective eX.inv⟦p⟧


have obtain obtain obtain obtain rw exact


obtain have rw rw infer_instance refine rw infer_instance simp


obtain have rw rw infer_instance refine rw infer_instance have have simp simp simp


obtain have rw rw infer_instance refine rw infer_instance simp rw


obtain have rw rw infer_instance refine inv rw infer_instance simp rw


suffices intro obtain have ext by_cases apply apply rw


constructor intro rw intro rw dsimp infer_instance exact


DerivedCategory.triangleOfSESIso

have refine dsimp simp dsimp simp dsimp rw


constructor rintro apply exact intro have rw intro rw apply exact exact inferInstance⟩


dsimp classical split_ifs exact apply obtain


constructor rintro obtain rfl exact exact obtain rfl intro obtain exact exact


constructor intro exact obtain exact intro exact


constructor intro by_contra exact intros dsimp lia


by_cases exact obtain apply intro simp obtain rw rw exact


by_cases obtain rw rw rw intro apply rw simpa


constructor intro obtain rfl have dsimp lia rintro constructor simp intro dsimp lia


constructor intro exact intro refine rw exact


rw constructor intro obtain exact rintro exact


by_cases rw by_cases rw obtain obtain obtain simp obtain obtain simp obtain obtain simp obtain obtain simp


by_cases obtain by_cases obtain simp exact exact


by_cases have have apply rw rw have apply simp have apply dsimp rw rw exact simp


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


simp constructor tauto intro by_cases obtain exact rw all_goals


ext by_cases obtain by_cases obtain simp exact exact


ComplexShape.Embedding.liftExtend.comm

by_cases by_cases obtain rw by_cases obtain rw subst simp apply have rw by_cases obtain rw dsimp rw have rw simp


constructor intro constructor all_goals constructor intros exact rintro rw ext apply by_cases obtain exact exact


have have dsimp rw apply dsimp rw apply congr symm apply


have have dsimp rw apply dsimp rw refine congr apply


constructor exact intro rw constructor infer_instance exact


HomologicalComplex.instEpiFπTruncGE

by_cases obtain dsimp rw infer_instance apply


suffices intro by_cases obtain dsimp rw infer_instance refine all_goals


have restriction.hasHomology have let have have have exact


have by_cases let parallelPair.ext exact have exact


rw by_cases rw dsimp infer_instance let have by_cases obtain dsimp rw infer_instance apply have dsimp rw exact have dsimp have rw exact exact


constructor intro refine rw exact intro rw intro by_cases obtain infer_instance rw all_goals


constructor intro exact intro by_cases obtain simpa exact


have rintro rw rw constructor intro simpa intro by_cases obtain simpa rw all_goals


constructor intro exact intro refine obtain exact


constructor intro constructor rw rw exact exact exact rintro refine obtain exact exact obtain exact exact


constructor intro constructor exact rw rw exact exact rintro refine simp obtain exact exact simp obtain exact exact


HomologicalComplex.ext

obtain obtain dsimp subst simp ext by_cases simpa rw


let let let τ₂ τ₃ have rw exact let let let τ₂ τ₃ have rw exact apply exact exact


have have apply refine dsimp have dsimp rw dsimp refine rw rw


have have apply exact dsimp have dsimp rw dsimp refine rw rw


by_cases obtain apply exact exact exact exact exact refine mono_of_epi_of_epi_of_mono have apply simpa


by_cases obtain apply exact exact exact exact exact have have dsimp simp have exact


ext dsimp simp shiftFunctorObjXIso, sub_zero]


constructor intro obtain exact rintro rw refine isomorphic_distinguished exact


ext by_cases subst by_cases subst simp simp simp


ext rw congr by_cases subst by_cases subst obtain simp rw all_goals rw subst by_cases subst by_cases subst obtain simp rw lia simp


simp constructor rintro obtain exact rintro exact


refine simp rw obtain simp exact simp rw rw


obtain clear induction zero succ intro rw dsimp


by_cases have ext dsimp rw δ_v γ.rightShift_v simp smul_add, simp have rw


by_cases have ext dsimp rw δ_v δ_v γ.leftShift_v simp congr rw simp simp congr linarith have rw


rw constructor rintro obtain refine rw exact rintro exact


obtain have rw one_smul] refine simpa ext


subst let have have simp one_smul, simp rw obtain refine intro obtain obtain rw δ_v simp rw simp


let have dsimp infer_instance have rw intro exact exact


constructor rintro tauto rintro ext rw replace replace simp simp exact


refine dsimp simp ext dsimp simp shiftFunctor_obj_X', ext dsimp simp shiftFunctor_obj_X, comp_id,


ext dsimp rw simp shiftFunctorObjXIso, comp_zero, dsimp rw simp comp_id,


constructor exact intro exact isomorphic_distinguished


obtain obtain obtain obtain obtain obtain have homotopyOfEq have have dsimp simp let have have dsimp simp refine simpa triangle_mor₁, simpa triangle_mor₁,


simp constructor intro obtain exact intro exact


cocycles dsimp rw cancel_epi apply ext obtain erw dsimp rw erw rw and obtain rw inr_f_fst_v, neg_eq_zero, inl_v_fst_v_assoc, conv_rhs rw dsimp rw dsimp simp comp_id,


rw dsimp rw mappingConeCompHomotopyEquiv_comm₁


by_cases by_cases apply simp simp apply simp rw


constructor rintro tauto obtain obtain rintro simp ext by_cases exact simp


have obtain dsimp by_cases obtain simp homotopyCofiber.inrX_d_assoc, homotopyCofiber.inlX_d rw ext simp dsimp simp comp_f, simp simp homotopyCofiber.inlX_d comp_f, rw ext simp simp


ext induction zero succ obtain all_goals dsimp simp congr cat_disch


constructor intro rw intro rw refine dsimp infer_instance intro exact


ext obtain constructor intro rw exact rintro rw exact


by_cases simp unit_tensor_d₁, rw dsimp simp simp


by_cases simp tensor_unit_d₂, rw dsimp simp simp


simp constructor intro exact intro exact


constructor intro exact intro infer_instance


rw constructor intro obtain exact rintro obtain exact


rw apply intro constructor intro refine rintro simp tauto


rw constructor intro refine rintro rw rfl intro rw


let let have have rw simp let have have rw simp have cokernel.desc simpa hx)) exact i wi hi wπ hπ


let let have have let have have rw simp have kernel.lift simpa hx)) exact p ι wp hp wι hι


rw constructor intro infer_instance apply


have have have simpa have have have rw rw refine apply rw dsimp rw exact


have apply refine refine dsimp rw refine dsimp rw


haveI rw constructor intro rw intro simp eq,


constructor intro rw rw apply rw intro exact


constructor intro have simp have have rw apply intro rw exact


constructor intro have simp haveI haveI rw apply intro rw exact


have let have have have exact i wi hi π wπ hπ


have let have have have exact p wp hp ι wι hι


have rw constructor intro have rw apply refine apply exact rintro refine rw rw


rw rotate_left dsimp rw dsimp rw dsimp rw rw have tauto


tfae_have hF, have refine let let τ₂ τ₃ comm₂₃ show exact tfae_have hF, refine apply let let have exact tfae_have hF tfae_have tfae_finish


tfae_have hF, have refine let let τ₂ τ₃ comm₁₂ show exact tfae_have hF, refine apply let let have exact tfae_have hF tfae_have tfae_finish


dsimp have simp γ'.left.leftHomologyMap'_eq,


rw dsimp leftHomologyMapIso', rightHomologyMapIso', simp


dsimp leftHomologyIso, homologyMap'] simp


dsimp rw dsimp leftHomologyMapIso', simp


have simp comp_zero] have dsimp refine rw rw


have simp homologyι_comp_fromOpcycles] have dsimp refine rw rw


let have have h.liftK dsimp rw let have have simp rw have have exact


let have rw have rw comp_id]) let have have rw have have exact


let have rw dsimp infer_instance have rw rw infer_instance


have have have have let have rw simp have have let parallelPair.ext refine exact exact i π wi hi wπ hπ


have have have have let have apply rw simp have have let parallelPair.ext refine exact exact p ι wp hp wι hι


ext rw dsimp simp leftHomologyMapIso'_inv, have have rw dsimp simp


have have rw infer_instance rw infer_instance


have rw constructor intro exact intro infer_instance


constructor intro infer_instance intro exact


let let suffices rw infer_instance simp e.inv_hom_id,


rw constructor intro haveI exact intro infer_instance


have rw dsimp constructor intro apply intro infer_instance


let haveI rw dsimp infer_instance have rw rw infer_instance


have have have constructor intro simp intro have apply


rw intro obtain have simp obtain refine simp


rw intro dsimp obtain dsimp have obtain dsimp let let have simp let have have simp sub_zero, exact


by_cases by_cases ext simp by_cases rw rw simp by_cases rw smul_zero] rw rw rw rw rw


by_cases by_cases ext simp by_cases rw rw simp by_cases have rw have rw simp totalAux.ιMapObj_D₁, simp rw by_cases rw rw simp rw rw rw rw


by_cases apply intro dsimp dsimp rw dsimp rw rw grind


by_cases apply intro dsimp dsimp rw dsimp congr rw rw grind


by_cases apply intro dsimp dsimp rw dsimp rw congr linarith rw grind


by_cases apply intro dsimp dsimp rw smul_smul, dsimp rw congr lia rw simp_all grind


ext dsimp rw ι_totalShift₂Iso_hom_f_assoc dsimp rw smul_smul, dsimp rw dsimp rw


constructor intro change have infer_instance intro infer_instance


by_cases ext dsimp rw dsimp by_cases have rw have rw dsimp rw rw


by_cases ext dsimp rw dsimp by_cases have rw have rw rfl rw rw


rw constructor rintro refine calc k rintro exact


rw obtain simp constructor rintro refine rw rintro refine grind grind


refine let let suffices simp induction mem induction mem zero add hv simp simp smul simp simp lie hv simp rw simp zero add hv simp simp smul simp simp lie simp simp


simp refine simp intro simp intro suffices rw refine simp intro simp intro simp intro simp intro simp


simp refine simp intro refine simp intro refine simp intro rw grind grind grind


set have rw lieIdeal_oper_eq_linear_span'] refine rintro exact rintro rw refine hm rintro all_goals


classical rw apply apply intro apply apply simp simp


rcases rintro set set replace replace let obtain simpa let let obtain suffices suffices apply apply set set let let let suffices apply_fun simp_rw r, intro rw exact this suffices simp_rw rw exact intro obtain apply apply rw apply apply lieCharpoly_coeff_natDegree intro rw let obtain refine exact dsimp simp refine simpa change ext exact lie_self z.1 have intro obtain apply_fun rw simpa apply obtain have rwa simp obtain use rwa obtain classical let have refine refine rw apply suffices apply obtain use refine refine lia intro simp exact apply apply lia dsimp rw intro rw if_neg let suffices replace intro simpa this z.2 intro change rw set have rw obtain use apply_fun rw rw clear induction zero succ classical set have obtain simpa specialize rw contrapose use refine apply rw


obtain use refine apply intro set suffices apply rintro suffices suffices apply exact rw apply


constructor intro have obtain replace le_antisymm refine rw rintro exact dsimp erw use rw self_normalizing have rw rw


rw induction mem simp obtain exact zero add smul


ext have simp lie_lie] rw have rw simp abel


constructor intro rw have simp rw rw abel intro ext simp rw abel


induction zero succ rw simp add_right_inj] refine rw


simp refine rintro obtain simp exact rcases exacts


suffices intro induction zero simp exact succ simp refine rw grw norm_cast gcongr exact


obtain obtain have suffices rw use simpa intro induction zero succ


Function.Surjective.isEngelian

intro letI letI have have haveI apply aesop


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


intro rw let replace rintro simp change let have suffices rw apply simp have rintro apply apply rw have have refine have apply intro simp simp exact exact haveI refine simp exact obtain obtain exact


apply intro rw specialize rw rcases rw use rw exact


set apply calc have intro rw specialize rwa have let obtain eventually_atTop.mp specialize rw apply rw apply rw intro simp use clear generalize induction zero cases exact succ rw apply rw rintro simp apply simp


rw intro let intro rw exact obtain use ext rw specialize rw obtain obtain exact have rwa


obtain rw change simp rw trivial_lie_zero


LieAlgebra.Extension.lieModuleOf

letI set exact m rw sub_eq_zero, exact lie_smul


ext choose have have trivial_lie_zero simpa aux replace simp nth_rw nth_rw simp abel


let lie_mem have obtain obtain simp use exact rw exact


apply let have intro refine hm rintro refine use use simp intro intro change rw exact rw


rw congr ext constructor rintro exact rintro exact


have constructor suffices rw rintro simp rw rcases use use simp


rw intro obtain rw let let change simp exact


suffices rw apply rintro obtain obtain exact


refine ext rw sub_self] replace simp simp


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


LieAlgebra.InvariantForm.atomistic

intro apply apply rintro exact by_cases exact obtain let suffices refine apply exact rw apply simp tauto suffices exact termination_by decreasing_by apply suffices intro apply rw exact


refine simpa intro apply apply simp intro rw rintro simp intro rw suffices rw apply exact


constructor ext simp_rw refine suffices rw simpa ext replace specialize rwa


rw intro rcases simp suffices let monotone have simp apply suffices aesop have simp simp forall_apply_eq_imp_iff₂] induction simp intro obtain exact have rw lie_add, refine exact exact exact set lie_mem hx rw apply set suffices rw rintro simp exact have suffices simp exact have have ext change simp rw have have obtain exact apply apply rw suffices intro specialize simp peel ext simp induction apply intro simp induction obtain simp_all obtain obtain use rw have simpa suffices suffices have apply apply use rw exact


obtain let have have let let set obtain have apply exact obtain have use refine rw intro have suffices calc calc rw simpa


obtain obtain use simpa rw exact lift intros exact obtain exact termination_by decreasing_by rw apply exact


let let have use obtain refine rw intro apply simpa


intro simp induction zero add smul_mem obtain rw exact


rw induction zero succ rw rw rw simp simp apply exact simp exact


induction zero succ simp have rw apply rw


intro induction zero succ intro rcases rw exact exact


have obtain h_wf.monotone_chain_condition refine rcases rw exact


induction zero succ have simp refine exact


apply induction zero succ simp apply assumption


LieModule.instIsNilpotentSup

obtain obtain let lowerCentralSeries have have refine simp


LieModule.nilpotentOfNilpotentQuotient

rw obtain use simp suffices replace rwa rw exact


let have obtain exact change rw refine rw exact


have simp let rw change have rintro exact exact


rw replace by_contra have contradiction rcases contradiction exact


refine nontriviality by_contra have le_inf_iff.mpr suffices rw exact


induction zero succ ih rw rintro simp have use simp obtain rw apply simp exact


refine induction zero succ ih suffices g simp simp_rw refine rintro obtain exact rintro obtain exact


constructor have exact have refine rw f.apply_symm_apply,


induction zero succ simp congr ext constructor rintro rw exact rintro rw exact


induction zero succ simp apply rintro exact


rw obtain obtain obtain obtain apply simp refine exacts


rw refine rintro suffices rwa rw intro replace rwa intro let have rintro rw mem_toLieSubmodule] exact simpa


induction zero succ ih rw simp rw rintro rw rw


LieAlgebra.IsSimple.instIsIrreducible

suffices rw have contrapose infer_instance


intro let obtain exact obtain by_contra exact classical let have have set suffices obtain exact intro obtain rw exact suffices have simp_all intro suffices rw ext exact rw constructor apply apply apply simpa suffices apply apply exact apply contrapose rw exact exact termination_by decreasing_by


rw intro apply rintro apply constructor intro ext simp have apply_fun exact


LieAlgebra.IsSimple.instIsSemisimple

constructor simp simpa intro apply rw rwa


have obtain rw intro specialize rw obtain suffices simpa


simp change change change rw mul_assoc, noncomm_ring


induction zero succ ih rw t.lie_lie_smul_f congr ring


induction zero simp leibniz_lie succ ih rw lie_f_pow_toEnd_f congr ring


suffices obtain refine have rw exact have infer_instance by_contra exact hs simp


intro induction exact have have simpa rw simp exact


induction zero succ have rcases rw exact rw


simp induction zero succ rw refine rw conv_lhs exact


intro simp induction zero add smul_mem obtain rw refine rw exact


rw induction zero succ rw rw rw simp simp apply exact simp


refine rw rintro use rw intro rw specialize rw rwa


rw let change have intro suffices change exact exact


dsimp split simp_all rename_i obtain have simp


refine refine iSup_induction exact exact rintro exact


constructor rintro simp contrapose rw rintro simpa


rw intro replace suffices replace have simp_rw rw


set have have have replace rwa shiftedGenWeightSpace.toEnd_eq, traceForm_apply_apply,


induction zero replace simp succ rw simp_rw refine rintro rw exact simp simp simp


replace intro induction zero succ intro replace have conv_lhs rw suffices refine simp_all clear simp obtain obtain simp


replace replace rw simpa refine intro simp simp simp simp


ext have have simp_rw exact classical have have simp exact


for and and required to rintro ext rw let suffices have rw exact rw replace simp rw exact replace simp intro exact apply exact exact trace_toEnd_eq_zero_of_mem_lcs exact


have classical have simp_rw traceForm_genWeightSpace_eq rfl


classical suffices rw simp refine replace simp


intro simp rintro let toEnd refine use swap rintro simp rintro change let let have ext simp toEnd_apply_apply, abel rsuffices use change rw map_zero] simp obtain obtain have simp have simp use have ext simp rw simp apply rintro suffices rcases rw rw


refine intro rw simp intro obtain use simpa


suffices intro obtain exact intro induction zero succ simp exact


refine apply rw intro obtain use ext set replace apply simp_rw apply suffices have simpa


rw intro simp intro have obtain refine simpa


refine simp simp intro have obtain use suffices simpa rw exact


refine suffices rw exact rw convert ext simp


set set rcases suffices replace rw infer_instance set set set set have have have rw exact have apply rw exact rw apply rw rwa


let suffices let rw exact induction ind refine suffices let rw exact exact


intro simp simp intro obtain use let let have change rw have rw simp exact


refine intro rw rw rintro specialize rw obtain rw use rw


have rw simp rfl simp_rw exists_exists_exists_and_eq] change simp


set suffices erw rw simp_rw rw ext simp exists_eq_right, refine convert simp


let suffices rw apply simp intro replace exact


rw induction mem obtain suffices apply simpa rw rcases replace exact zero add


rw induction mem obtain let map_add map_smul let map_add map_smul have ext rw simp simp zero add smul


obtain let let have replace refine rw exact refine let have rw refine exact have have simp_rw rw subst erw simp_rw convert_to simp_rw


classical rw apply rw intro have rw exact exact


refine have induction zero mem obtain use have rwa add obtain obtain refine rw add_zero]


have have apply exact convert ext have genWeightSpace rw exact add_mem let have genWeightSpace by_cases simp let have refine rw exact have genWeightSpace_le_I have genWeightSpace_le_I have rw exact w_minus have genWeightSpace_le_I exact


let have have by_contra let have obtain obtain have rw exact have rw exact have by_contra let have obtain obtain have rw exact have rw exact h_chi_not_in_q rw convert rw obtain obtain have apply intro intro intro have rw exact intro have rw exact have have rw exact rwa have have rw exact rwa have have have rw have exact have have rw exact have have obtain rw exact rw have exact rw simp


refine have rw have exact by_contra have contrapose have rw exact obtain have have have rw obtain obtain simp rw hy, have convert have have convert rw rw exact have simp exact


refine by_contra have have hq_nonzero rw obtain rw have have rw exact rw simp exact simp


have replace rwa rootSpace_zero_eq suffices simp intro exact


rw ext have induction mem by_cases exact exact zero add


suffices simp exact simp ext have rw rw exact


refine suffices refine rintro suffices simpa simp


set rw apply simp refine simpa intro replace have have simp


obtain have obtain contrapose simpa suffices exact


rw refine suffices simpa rintro simp tauto


refine intro have rintro rw exact simp replace rw rw obtain solve_by_elim simp exact


rcases replace refine obtain simpa simpa


rw induction mem obtain change replace rw zero_smul, zero add smul


have replace simp refine simp specialize simp mul_eq_zero, simpa have rwa


refine have rw rwa ext simp have contrapose simp rwa have suffices apply rw simp


obtain obtain contrapose simpa have let have have simp rw rw exact let replace have rw refine rw have simp contradiction have rw simp


have lift congr have have rw exact suffices obtain replace rwa set have simp rw use have have contrapose simpa rw


suffices have convert_to simpa lia intro obtain let have obtain replace have simpa have lie_h simp lie_eq_smul_of_mem_rootSpace lie_e obtain assumption_mod_cast


simp generalize_proofs obtain obtain exact obtain obtain exact have rintro simp exact have rintro simp exact simp_rw refine simp simp


ext obtain refine replace obtain refine exact exact suffices refine rw have obtain exact obtain obtain obtain obtain obtain simpa change rw use simp


replace obtain simp_rw refine intro have rwa


obtain by_contra simpa obtain simp exact


by_cases exact obtain obtain have have obtain exact


by_cases simpa obtain obtain obtain have have simp exact


by_contra let have have have simp lia have simp congr ring have rw exact


by_cases rw apply rw intro apply rw add_smul, exact rw intro apply rw neg_add, exact


contrapose lift rw have rwa neg_add_cancel,


constructor refine rw apply rwa rintro set lift rw subst simp have rwa


symm apply rw intro exact α.2 obtain obtain obtain have have obtain have convert rw simpa apply_fun simp intro refine have simp rwa


by_contra let have change rw apply have rwa


cases exact have rw simp rcases rw simp rw have rw set subst have change exact simpa apply_fun rw have have swap simp rw lia rw simp cases


intro have by_cases simp simpa have exact


intro rw split_ifs exact dsimp rw congr rw simp


refine intro set set change suffices rw ext exact


rw simp constructor intro simpa intro simp exact


by_cases simp suffices clear intro rw simp suffices clear intro rw rw


erw rcases apply_fun rw split_ifs cases rwa grind


let have apply convert rw exact exact exact intro rw suffices rw exact rw exact


classical let let have obtain exact choose have have have refine let convert ext constructor intro refine simp simp rw rintro simp


classical obtain obtain have apply choose have rw exact


classical obtain have obtain choose exact have rw rintro obtain obtain rw exact apply rw exact rw exact


obtain apply rw rw refine let have have let have have rw apply rw change have rw exact


Module.FinitePresentation.pi

refine exact exact infer_instance introv infer_instance


Module.FinitePresentation.trans

obtain let refine obtain exact have simp exact


instFinitePresentationTensorProduct

classical obtain have apply have lTensor_exact rw rw have exact


obtain let have classical choose let let have ext simp rw exact have intro convert_to simp apply rw convert rw exact choose let have rw intro simp rw convert exact refine ext obtain rw congr convert ext apply simp


classical have choose obtain use rw intro simp


obtain have have apply apply simp rw simp rw exact obtain let let have isUnit_of_dvd_unit have refine apply map_units ext apply have simp algebraMap_end_apply] rw simp


constructor intro rw have constructor exact intro use ext exact intro obtain refine apply refine intro apply ext simpa


have obtain exists_bijective_map_powers convert apply exact simp have refine intro obtain obtain obtain simpa exact exact


GradedModule.linearEquiv

letI refine intro classical rw map_sum, refine rw refine rw from simp convert rfl


obtain have change rwa have simp unfold rw congr ext dsimp rw exact


obtain replace rw replace rw obtain have rintro simp rw exact


simp rw simp congr apply intro simp rintro simp classical rw suffices toMvPolynomial simp suffices rw rw rintro rw grind intro rw dsimp rw


rw charpoly.univ_map_eval₂Hom] congr ext rw rfl


rw constructor intro exact intro rw apply apply


let let let have polyCharpoly_coeff_isHomogeneous obtain by_contra apply apply simp let use rwa


ext constructor rintro use simp rw rintro use rw simp


induction induction rw rw rw congr simp rw


induction rw show rw mk'_smul_mk, congr simp rw


induction h induction h rw simp fconstructor rintro refine rw rintro refine rw


intro obtain obtain suffices apply rw rwa simp


intro obtain obtain simp forall_exists_index, intro exact


IsLocalizedModule.mkOfAlgebra

replace rw simpa constructor intro rw constructor rintro simp_rw exact intro refine rw exact intro dsimp rw simp_rw exact


classical choose refine exact simp rw congr simp rw


delta rw ext constructor rintro rw exact rintro exact


let have apply rw replace rw obtain obtain use convert convert simp


simp refine rintro have rw obtain refine rw exact rwa


apply rintro refine intro rw exact simp refine rintro rw exact


ext simp refine obtain simp obtain refine rintro simp


classical refine exact rintro have haveI exact


have have rw convert rw exact obtain refine rw f1.choose_spec]


obtain induction zero use rw haveI exact succ have obtain let have obtain clear have intro let obtain simp refine exact refine rw rw ext simp rw exact have rw simp rw exact


obtain have exact torsion_by_prime_power_decomposition. classical refine simp


have refine le_antisymm rw obtain rw simp_rw exact rw exact


constructor intro rw intro rw intro obtain replace rw obtain simp


let map_add map_smul change have have refine rw simp congr aesop rw rw dsimp rw rintro simp refine simp rfl


constructor intro obtain obtain exact relation var linearCombination_var_relation rw exact toIsPresentation rw exact inferInstance, rintro exact


constructor rw rintro exact rintro exact


obtain projective_lifting_property refine rw


obtain let map_add map_smul refine replace simpa


Module.Projective.tensorProduct

obtain obtain have fapply exact exact ext fapply exact exact ext


haveI intro constructor intro obtain obtain obtain exact rintro simp rw


rw apply refine rw exact have rw refine have ofENatHom.monotone apply rw exact


rw rcases rw exact simp_rw apply exact refine by_cases exact rw exact


rw constructor rintro obtain csInf_mem refine simpa rintro exact


refine have rw refine rw exact apply simp


constructor intro obtain simp simp_all rintro exact


rw refine le_antisymm refine simp rw exact


apply rw apply on_goal intro apply intro exact all_goals intros simp rw intro exact


nth_rw rw induction zero succ simp_rw calc


induction zero contrapose induction zero succ rw exact succ rw iterateMapComap,


rw refine intro have rw simpa rintro have rw simpa


let smul_mem simp_rw induction mem obtain suffices apply rw exact zero add refine exact exact


classical apply intro exact intro obtain simp rw refine rintro rw rintro exact ext simp fconstructor refine rw exact simp_all


fconstructor intro rw obtain exact rw rintro rw exact


fconstructor intro induction smul₀ rcases exact add rcases rcases exact zero aesop


constructor intro use rw exact rintro rw intro simp rw obtain have have apply simp suffices exact


classical induction empty insert simp rcases simpa replace specialize contrapose replace simpa suffices intro rcases simpa obtain have let have suffices rw rintro rw contradiction obtain suffices obtain exact choose have suffices obtain exact simp_all, have refine have have rw obtain exact replace have refine rwa replace simpa


Ideal.iSupIndep.linearIndependent'

refine replace simp have rw refine convert ext simp rw simpa


refine rw suffices rintro exact rw exact


rcases simp apply apply intro apply intro apply exact intro rw obtain refine rw rintro rw suffices rw intro rw intro by_cases rw exact have simp exact rw


constructor intro let dsimp use rw apply intro let exact


ext obtain rw obtain rw use rw obtain rw smul_zero]


classical calc suffices convert exact rw apply rw exact


ZSpan.quotientEquiv

refine refine rw exact refine rw apply rwa obtain exact


cases refine ext rw simp_rw refine rsuffices rw exact


cases haveI let rw refine exact ext simp


classical have rw suffices refine refine simp_rw exact intro simp_rw not_forall, obtain have rw refine exact


ZLattice.FG

obtain exists_linearIndependent refine refine let rw exact rw have refine have change have exact refine rintro rw refine exact rw refine rw exact rw exact


let let have rw exact suffices have convert have refine exact have rw range_subtype, exact


ZLattice.rank

classical have have have let let have have convert rw rfl exact have rw exact have rw rfl exact rw refine obtain exists_linearIndependent let have have rwa contrapose obtain rw contrapose rw replace rwa suffices contrapose refine exact rw linearIndepOn_id_insert intro have rw refine rw refine exact exact have change have exact obtain have apply refine rwa rw convert


Module.Basis.ofZLatticeBasis

have have let have refine rw hs.span_top] rw


let let let have let exact have rw exact


have let convert refine rintro let refine simp


classical let let rw trans rw mul_comm, congr rw congr rw exact


let have rw covolume_div_covolume_eq_relIndex


classical let let have rw volume_image_eq_volume_div_covolume simp


refine filter_upwards congr refine simp_rw rw exact exact


refine filter_upwards have have have have obtain rw congr refine rw image_smul_set, inv_mul_cancel₀ simp_rw b.ofZLatticeBasis_span rw exact exact simp_rw apply rw exact


classical let refine rw let convert simp rw rw


let convert simp rw have infer_instance rwa rw exact


wlog let let have let have obtain exact have let let have obtain refine by_cases simp have have simpa rw abs_eq_self.mpr exact


let subst set have by_cases have simp replace have have intros simp exact have trans simp simp gcongr have norm_num zify convert rw simp rw let have calc simp gcongr rw refine obtain refine suffices by_contra rw exact simp gcongr refine gcongr lia simp_rw congr push_cast rw group congr rw norm_cast gcongr rw positivity gcongr refine linarith


classical cases refine have simpa classical let have let simp_rw set have let obtain refine let obtain dsimp simp obtain obtain refine have have simp simpa refine dsimp simp convert simp by_cases refine rw exact refine rw refine rw refine simp refine simpa


cases exact refine have refine intro by_cases simp by_cases simpa have have rw simpa have rw simpa


classical let calc simp sum_subset simp by_cases rw rw


refine sup_support_multiset_prod_le exact exact


classical refine rw split_ifs intro rw exact


classical simp_rw rw refine apply_fun exact intro refine apply_fun simp_rw have exact he refine rw


obtain rw apply_eq_zero_of_not_le_supDegree rw


classical rw by_cases rw suffices refine exact rw


obtain obtain by_cases refine rw obtain apply have rw exact


obtain simp obtain simp obtain obtain simp_rw exact


apply rw exact exact simp_rw exact have have exact


refine refine apply refine refine rw rfl


classical obtain revert refine intro symm exact intro have simpa rw obtain have subst simp let dsimp rw apply congr


classical let add_mem zero_mem smul_mem hm simp obtain obtain obtain refine rintro exact change constructor suffices rw rintro refine simpa intro rw apply obtain simpa


classical simp_rw refine refine exacts refine rcases rw rw


let map_zero map_add change revert rw ext simp


intro apply change exact intro have intro induction zero succ simp


classical split_ifs conv_rhs rw contrapose rw obtain simpa exact


constructor rintro rw apply intro choose classical let let use apply intro simp split_ifs rw rw rwa


ext simp have notMem_support_iff.mp have notMem_support_iff.mp have by_cases refine obtain exact exact rintro exact exact


classical simp constructor rintro simpa rintro split


classical refine rintro rw exact rintro simp split


simp refine by_cases exact convert simpa


classical refine intro induction mem_mul_mem rw apply add rw intro rw exact


funext trans apply rw suffices exact simp refine ext apply


classical apply intro rw obtain rw refine rw suffices rw obtain contrapose rw refine all_goals


classical intro rw rintro obtain simp rw contrapose rw intro simp specialize rw


refine apply have simp apply intro simp use simpa


classical apply rw exact by_cases simp obtain p.support.exists_mem_eq_sup have contrapose rw apply have apply rw exact rw exact


classical rw specialize rw refine exact exact


classical rw refine replace let let have have have rw exact


refine have have intro induction monomial rw smul_comm add intro induction add mul_X simp rw


constructor rintro rw have have classical simp_rw simp_rw split_ifs exact exact rintro simp_rw refine rw


refine contrapose intro rw apply simpa obtain apply rwa


nontriviality have constructor intro suffices simp rwa have have rw intro contrapose intro classical rw apply intro simp simp rcases rw simpa rw simpa nth_rewrite nth_rewrite simp simp simp apply rintro exact exact


constructor rintro have apply rintro obtain exact intro refine rw rw use rintro exact suffices rw exact conv_lhs simpa


rcases simp refine suffices p from classical intro induction zero intro rw simp implies_true] succ intro refine obtain rw intro simp let have apply rwa have have rw simp rw rcases obtain exact obtain obtain use simp simpa rw apply apply


MvPolynomial.sumRingEquiv

apply refine ext1 intro simp ext1 rintro


induction monomial rw classical simp simp by_cases simp rw simp intro apply simp simpa add


let commutes convert exact change congr apply rw simp


ext rw constructor rintro refine rw simpa rintro refine rwa


classical by_cases rw rw intro refine simp simpa


induction add monomial r simp rw obtain simpa coeff_monomial simp obtain simp simp have rintro rw contradiction simpa coeff_monomial


have rw exact have let convert rw rw exact


ext rw conv_lhs congr ext rw constructor grind intro use rw simp


classical apply intro simp intro simp intro exact calc simp


unfold have dsimp rw congr ext1 simp ext1 simp


classical apply intro simp_rw intro simp intro simp


apply exact simp intro contrapose rw exact


classical induction mul_X monomial_add ih rw rw exact exact


classical refine obtain exact induction by_cases subst exact simp obtain exact mul_X rw obtain exact monomial_add ih rw simp obtain obtain exact


ext rw mem_range_map_iff_coeffs_subset, simp


classical replace intro by_cases exact rw exact induction monomial_add rw refine simpa have rw split_ifs subst rw exact rwa


classical rcases simp by_cases rw simp_rw simp congr rw simp


induction zero apply rw convert succ apply rw apply apply rintro refine rw exact


suffices rw intro simp_rw intro obtain suffices refine choose convert simp obtain rw simp_rw


calc simp apply intro calc vars vars_mul simp apply intro apply intro simp_rw rintro exact


classical refine have intro rw simp simp isEmptyRingEquiv_eq_coeff_zero] intro obtain simp


classical refine intro obtain let have simp convert refine simp have simpa


rcases simp classical induction empty insert simp obtain simp degreeOf_mul_eq


constructor intro use suffices rw refine rw simpa apply simpa rintro exact


by_cases simp classical simp_rw rw simp have intro exact simp_rw contrapose ext apply simpa


rw apply intro constructor rintro rw obtain use rw rintro use rwa


rcases suffices use rw apply intro simp_rw


rw apply intro constructor rintro simp suffices by_cases left ext simp by_cases rw exact right ext apply by_cases simpa simp rintro use use simp


classical induction add mul_X simp cases


simp conv refine simp simp congr funext refine


classical apply intro exact rintro refine refine simp simp rfl rintro refine refine simp simp rfl


obtain obtain classical use use use constructor


classical apply φ.induction_on intro rw simp intros simp


classical rw intro replace rw obtain specialize rw contradiction


classical rw constructor rintro refine simp intro exact


classical induction zero succ rw apply exact


classical induction empty insert simp apply exact


classical induction empty insert rw refine assumption


classical induction empty insert hsum rw unfold simp grind


conv_lhs simp by_cases on_goal rw intro on_goal rw rw rfl on_goal on_goal rw intro contradiction repeat obtain rw rw rintro contradiction rw rw rw exact


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


refine simp contrapose ext1 rcases simp simp


refine refine by_contra have rw simp_all


simp constructor rintro refine rw apply intro rw rwa rintro refine simp apply rw apply intro rw


intro simp rintro simp constructor rw exact


ext constructor apply set intro have rw apply rw convert rw convert apply


unfold split_ifs simp_rw toMul_ofMul, constructor rintro exact rintro refine apply exact simp simp


ext simp constructor intro refine exact rw exact


ext simp constructor rintro exact simp_rw rintro have rw obtain exact lia obtain use simp rw simp_all exact


rw rw obtain refine intro by_contra apply apply apply rw mul_assoc] apply


contrapose simp_rw intro use dsimp apply rw convert rw rw rw push_neg intro rw rintro rw exact


have choose refine simp funext have trans rw congr grind rw rw exact


rw refine apply use dsimp rw ring refine use


obtain have have rw exact have rw exact have rw exact funext


dsimp let let have rw rw refine rw dsimp rw use apply apply apply


Finset.piAntidiag

refine rintro ext simpa ext simp refine have simp_all


rw induction simp constructor rintro rw exact rintro refine rw exact


ext simp constructor rintro refine have aesop rintro have aesop


ext refine simp constructor rintro simpa rintro have by_cases exact rw exact refine simp grind


ext simp exists_and_left, constructor rintro simpa rintro refine simp simpa


ext suffices rw simpa rintro constructor rintro exact rintro exact


let obtain have obtain have intro apply rw exact obtain have contrapose exact refine rw exact


have classical exact let have have have have


classical have obtain use rw exact have obtain refine contrapose rw exact obtain exact


have refine by_contra have intro simp exact rw exact


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


have have have refine exact exact let have let have have lt_max_iff.mpr have calc refine rw abs_eq_self.mpr exact le_sup_left.trans_lt


obtain obtain have norm_cast obtain refine


WithBot.instArchimedean

constructor intro cases bot coe cases bot coe


WithZero.instMulArchimedean

constructor intro cases zero coe cases zero coe


induction singleton cons intro obtain rw have have by_contra obtain rw exact rw obtain rw congr apply intro obtain rfl refine apply rw exact rw congr refine intro obtain apply rw exact exact


intro induction mk induction mk simp_rw obtain intro exact


intro rw rw rw refine contrapose apply simpa


have intro rw rw obtain refine rw exact exact


constructor have refine exact rw intro obtain obtain obtain use grw have intro rw exact rw contrapose intro rw push_neg obtain exact


simp exact smul_le_smul_of_nonneg_left positivity


induction nil cons simp have apply apply simp grind grind apply


a simp have apply apply simp apply intro apply apply simp intro apply apply simp apply grind apply


have classical calc rw exact mul_le_of_le_one_of_le


classical calc rw exact apply simp intro simp exact


classical revert refine specialize rw exact mul_eq_mul_iff_eq_and_eq


classical refine replace grind by_cases obtain have simp simp


induction empty simp cons hr simp_rw not_true_eq_false, have simp simp_rw exact


induction slnil cons simp exact cons₂ simp grw


induction nil cons simp simp cases exact exact


induction nil cons simp rcases simp specialize simp exact


induction nil cons rw by_cases simp have have have grw


induction simp simp_rw constructor exact exact


induction empty cons simp have gcongr exacts


classical obtain rw have refine exact exact exact


classical simp_rw refine rw gcongr apply simp exact


obtain have sum_eq_zero rw simp refine calc gcongr have grind refine le_of_eq_of_le repeat


revert refine intro by_cases simp have have rw exact


have have refine replace replace set have rw simpa


refine have have rw abv_sub refine rw refine gcongr exact


IsCauSeq.bounded

obtain set have refine rintro simp exact refine obtain exact simpa


by_contra refine simp obtain rcases refine have rwa


CauSeq.trichotomy

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


obtain intro refine dsimp rw rwa rw exact refine rw


obtain intro refine dsimp rw rwa exact refine rw


obtain obtain exact replace refine exact replace refine exact


intro obtain exists intro have have have have rw refine generalize clear rw rw dsimp clear induction zero succ simp simp simp grw


let let have have let have div_pos let refine have simpa have simp have have have have have rw div_mul_cancel₀ have have calc have gcongr refine rw gcongr exact exact have calc rw refine suffices ε rw simpa gcongr exact rw calc gcongr rw grw rw gcongr rw have gcongr exact hM


have refine simp conv have refine intro rw gcongr exact refine exact intro rw gcongr


have refine obtain have have simpa generalize replace induction zero rw positivity succ ih have rw refine exact


classical obtain rw exact sum_le_card_nsmul hfg.sum_smul_comp_perm_le_sum_smul


refine rw obtain refine norm_cast rw exact rintro refine rw exact


obtain obtain trans exact rw exact mul_self_le_mul_self


obtain refine rw exact obtain rw refine rw push_cast obtain exact


by_cases have have rw apply exact simp apply rw simp


refine obtain simp_rw exact refine convert rw


obtain exact simp_rw obtain simp have rw exact rw exact


refine rcases exact obtain obtain exact d_ab.le.trans


wlog have exact have zero_lt_one.trans_le le_add_of_nonneg_right mul_nonneg refine rw obtain simpa refine refine mul_le_mul_of_nonneg_left refine exact


rcases rw apply simpa rw apply simpa simpa


cases cases obtain obtain choose obtain have obtain exact


lift cases simp norm_cast exact simp norm_cast rw lia


rw constructor rw exact refine simp conv simp


induction zero succ rcases rw rcases use rw abel


ext simp rintro exact rintro obtain exact


rcases simp have refine positivity simpa rw norm_cast rw


rcases simp replace have intro obtain rw rw simp obtain exact let let have calc fract rw simp congr simp rw


rcases exact right suffices rw abel norm_cast rw refine rw exact


obtain simp have refine rw convert field


rcases rw simp apply refine rw cast_mul,


refine have have ext rcases rw refine rw cases cases congr


have rw simpa mul_lt_mul_of_le_of_lt_of_nonneg_of_pos


refine obtain exact refine obtain refine refine lift obtain obtain exact lift obtain exact


WithZero.instMulLeftMono

refine induction induction rcases rw exact


WithZero.addLeftMono

refine induction rwa induction rw induction rw rw exact rcases rw gcongr


WithZero.instMulLeftReflectLT

refine have induction simp induction simp induction exacts


rcases refine exact rw exact refine exact


obtain simp exact swap simp have simp refine obtain refine rwa rw rw cases


intro rcases rcases rcases rcases suffices rw simp_rw simp_all rcases simpa rcases rcases suffices simp_rw simp_all


rcases rw simp_all have have have simp simp simp


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


SemigroupIdeal.instWellFoundedGT

rw intro rcases have intro apply simpa choose exists intro apply apply intro rw rcases exact


by_cases rw rw refine rcases exact rw simp simp


by_cases simp_all rw simp rcases refine simpa


simp refine grw intro by_cases obtain rw refine obtain refine rw rw exact


set calc rw gcongr refine rw have rw rw rw gcongr refine rw


refine simp intro rw congr split_ifs simp intro rwa


ext constructor rintro dsimp constructor rintro obtain refine rwa


refine obtain obtain refine rwa obtain refine rwa


rw constructor apply convert rw rw convert rw


refine rw have refine nth_rw nth_rw rintro rw


simp simp_rw intro apply have have rwa have have rw exact


have obtain obtain simp_rw refine rw exact have rw exact


obtain refine exact rw exact refine exact


simp refine obtain exacts smul_neg_of_neg_of_pos


apply contrapose have exact apply rw exact


intro rw intro obtain obtain contrapose rw by_cases have have intro change rw rw exact rw u.archimedeanClassMk_of_mem_stratum by_contra obtain contrapose have rw simpa rw symm simpa


suffices simp have apply simpa let have apply simp have change apply rw simp simp


have simp_rw obtain have rw simpa have obtain contrapose apply intro simpa refine intro rw rw simp contrapose rw exact rw suffices simpa suffices apply simpa apply rw have sub_eq_of_eq_add rw have intro simp rw rw exact rw rw by_cases rw rw apply apply simpa


have simp_rw obtain let refine rw use apply_fun rw ext rw unfold obtain rw apply have simp aesop rw have simp convert simp


have have rw let have apply_fun rw ext rw unfold obtain simp simp


obtain have simp have obtain have rw simp_rw rw


by_cases simp have obtain have apply simpa let have have rw unfold simpa have rw simp


obtain simp apply apply_fun rw apply simpa


apply rw refine have push_cast simp rw exact


rw by_contra have specialize contrapose simp obtain have specialize rw convert refine simpa obtain contrapose rw simpa


by_cases simp unfold rw ext suffices by_cases obtain have have rw exact simp have contrapose obtain use have exact simp


have rw apply by_cases simp have rw simp_rw apply simpa have intro rw exact contrapose exact


have rw let have rw obtain have rw have by_contra obtain contrapose simp_rw obtain exacts


unfold rw ext simp obtain rw exact rw apply contrapose obtain exact


set have by_contra have obtain rw contrapose exact


rw have refine intro apply simpa suffices obtain rw have have change refine simpa have apply simpa have suffices have rw refine rw simpa hz rw obtain have apply by_contra obtain contrapose rw apply contrapose rw have exact exact


have contrapose rwa intro rw apply rw obtain nth_rw obtain have rw have obtain rw simp_rw rw suffices rw exact have rw exact by_cases rw suffices exact exact


rw by_cases obtain obtain refine rw rw rw ext obtain simp_rw refine simpa simp_rw refine apply_fun rw ext obtain rw rw apply contrapose obtain exact


obtain rw obtain obtain simp_rw rw rw refine obtain refine rw exact apply


apply change simpa by_contra have rw contrapose simpa


intro apply rw obtain simp_rw obtain have rw obtain have rw apply rw simp


obtain simp_rw obtain obtain obtain simp_rw obtain have apply exact refine have have simpa


obtain refine rw contrapose obtain exact


obtain obtain obtain obtain refine apply intro simpa simp_rw simp


OrderedSMul.mk'

have refine rw exact refine obtain rw refine simp


rw apply intro rw rintro constructor rw apply rintro rw rw apply


have ext simp constructor rintro obtain exact aesop simp


refine suffices obtain exact have obtain exists_covBy_of_wellFoundedLT use have suffices ext simp constructor rintro by_contra have simp exact rintro simpa


obtain grind left obtain grind exact exact


classical revert apply simp intro set have intro simp split_ifs obtain contradiction exact exact exact specialize simp_rw grw obtain rw have rw refine rwa simp rw simp refine specialize rw rcases exact exact specialize rw rcases exact exact rw rw rintro exact


classical refine simpa rw push_neg obtain set have refine obtain refine obtain cases simp refine simp_rw rw


have refine apply rw congr convert rw rw convert rw rw exact


induction zero succ refine rw refine rw exact mul_le_mul


induction zero succ rw sub_add_sub_cancel]


induction mk induction mk induction mk simp_rw


induction mk induction mk induction mk simp_rw obtain simp_rw refine


have constructor rintro simp_all obtain refine simpa rintro have obtain refine have rw exact simpa


rcases induction zero succ let have have calc x rw exact rw add_assoc rw exact


calc simp_rw cases exact exact mul_add_mul_le_mul_add_mul


have intro obtain exact obtain exact obtain obtain have refine dsimp calc a refine rwa


have have rwa have have rwa rw rcases exact simp exact


have induction zero succ simp split_ifs rw exact grw gcongr simpa


refine rw exact clear intro rw exact mul_neg_of_neg_of_pos


have refine simp clear intro simp split_ifs rw exact grw gcongr simpa


rcases exact simp rw rcases have simp exact simp exact


refine rw refine simpa rintro exact exact


obtain cases simp rw obtain have split_ifs exact exact exact


refine contrapose have rcases rw simp exact


obtain have exact obtain have exact rw have let let refine have rw mul_comm rw by_contra replace apply have rw calc n


induction empty cons simp by_cases simp obtain rcases exact exact


induction singleton cons simp rw rcases exact exact


obtain simp forall_true_left] refine simp rw exact


rw intro rcases set set rw ring_nf aesop


refine by_contra have have simp_all have refine by_contra have have have have cases


refine rintro have rw mem_nonunits_iff, apply


induction mk induction mk induction mk rw rw rw grind


obtain unfold have rw apply suffices ext apply aesop rw rwa


have obtain obtain cases rfl obtain cases


obtain obtain obtain have have refine by_contra exact apply simpa obtain exact rw have obtain convert rw exact convert rw exact


constructor rintro rw exact intro rcases exacts


have lift lift obtain rw exact obtain rw exact lift lift norm_cast obtain rw exact exact


rw split_ifs rw simp simp suffices refine apply have suffices contrapose grw simp


rcases rw rcases obtain rw refine exact rw


rw rcases conv_rhs simpa rw conv_rhs rw norm_cast rwa


induction zero add mem induction zero add mem obtain obtain exact


suffices intro rw obtain refine refine rintro exact


rw obtain refine have induction all_goals


WithTop.instOrderedSub

constructor rintro cases cases cases simp cases simp norm_cast exact


cases simp rename_i simp by_contra simpa


suffices rwa rw apply obtain rw rw refine rw


rw tfae_have rw exact tfae_have h rw exact tfae_have h rw refine rw conv_lhs tfae_have rw have exact tfae_finish


let let have have have suffices obtain simpa rcases suffices apply exact have apply exact have contradiction


constructor suffices have have rw exact by_contra rw exact rw exact


by_cases rw rw refine apply intro exact convert rw simp


simp have calc rw swap simp rw conv_lhs congr arg simp rw simp


induction add simp_rw exact monomial dsimp rw solve_by_elim


suffices rw apply simpa apply use intro rw intro obtain apply rw suffices rwa let suffices rw apply simp intro obtain have rw lia rw termination_by


refine by_contra obtain refine contrapose exact


have intro induction zero succ have apply convert exact intro rw exact rw exact


refine contrapose intro rw obtain rw exact


obtain simp_all replace suffices apply aesop simp_all


apply intro by_cases subst simp rw apply rw use simp


induction nil cons have simp rw have refine rw refine simpa exact


induction empty cons simp rw rw simp apply rw exact simp apply


nontriviality convert rw swap rw swap simp rintro apply simp_rw obtain exact congr


nontriviality rw simp_rw rintro contradiction


induction add monomial induction add monomial simp_rw simp


by_cases convert simp rw by_cases exact apply compute_degree rwa contrapose rw add_comm simp rw


constructor rintro rw apply intro choose classical let let use ext simp split_ifs rw rw rwa


constructor intro apply_fun simpa rintro rfl


have have simpa withBotSucc_degree_eq_natDegree_add_one


by_cases rw simp by_cases have simpa nth_rewrite simp have have obtain use have lia rw apply rintro obtain simp_all simp by_cases rw obtain rw conv_lhs equals rw congr lia by_cases simpa rw rw congr lia simpa


by_cases simp apply exact simp apply simp


Polynomial.IsMonicOfDegree.mul

rcases simp exact refine have rw exact rw


nontriviality rw rcases rw replace replace rw


rcases simp exact have refine have have rw exact rw exact


refine refine rcases obtain simp simp exact


rcases simpa simpa coeff_eq_zero_of_natDegree_lt


classical induction empty insert simp specialize rcases rw rcases simp obtain rw by_cases simp have contrapose simpa refine simp simp exact rw


by_cases obtain have refine rw rw refine rw intro by_cases simpa rw exact rw intro simp by_cases refine contrapose simpa exact exact rw intro simp


refine rw simp_all ext obtain simp simp simp rw simp rintro simp


induction zero succ rw by_cases rw by_cases rw apply have refine rw exact calc rw exact


rw rw rintro obtain rw obtain rw obtain exact


constructor rintro by_contra obtain obtain exact rintro simp


apply refine rwa rw intro have rw exact rw exact


have have rw trailingDegree_eq_natTrailingDegree trailingDegree_eq_natTrailingDegree exact


rw refine rintro rw by_cases rw by_cases rw refine exact


have have apply rw trailingDegree_eq_natTrailingDegree


refine nontriviality rw ext rw obtain rw simpa rw


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


rw simp rw simp intro cases intros rw intro rw simp_all


induction subst obtain rw by_cases rw have exact


rcases exact rw by_contra rw let have have rw rw replace rw exact


induction add monomial induction add monomial simp simp cases zero succ cases zero succ


apply rw apply intro apply apply refine rw rw intro rw exact exact


induction zero succ calc derivative^ derivative simp_rw sum_add_distrib] rw congr refine rw refine rw congr lia rw


have derivative^ simp_rw congr norm_cast ring rw refine rcases replace simp simp


convert rcases rcases suffices simp ring rw exact


refine rw congr rw simp refine rw by_cases simp simp


induction exact by_cases simp rw by_cases simp hP have contrapose exact refine linarith


classical induction simp specialize nth_rewrite rw derivative_sum, congr calc congr simp_rw rw grind apply intro intro all_goals rw grind rw congr simp


by_cases rw contrapose exact haveI exact


nontriviality by_cases cases rw exact rw


nontriviality have have have calc degree rw exact calc degree


nontriviality by_cases rw rw rw have rw push_neg have have intro apply rw rw rw


nontriviality have eq_of_sub_eq_zero rw simp have have calc degree have not_le_of_gt calc degree rw norm_cast exact exact


nontriviality haveI have div_modByMonic_unique calc exact


nontriviality have set rw have degree_X_sub_C simp


wlog refine rw pow_zero, congr ext rw apply rw exact rw nontriviality by_cases rw apply apply rw exact


cases rw classical rw split_ifs rfl have simp_rw


nontriviality have rw sub_zero] have have revert cases exact exact rw rw


by_cases simp apply have rw apply all_goals apply simp


obtain rw have set set have rw rw reverse_leadingCoeff,


classical simp_rw refine rcases rw apply exact


nontriviality have simpa nth_rw rw rw exact


rcases simpa replace obtain rw rw rw mul_eq_left₀ rw


by_cases simp by_cases rw by_cases simp suffices rw linarith have simpa have rw linarith have rw obtain have simp rw simp ext rcases have rw rw rw add_eq_left] rcases simpa rw trans grw simpa grw simpa


induction zero convert simpa succ rw cases convert convert rw rw exact refine refine exact rw rintro simp exact exact refine rw exact


refine induction_with_natDegree_le intro rw intro rw by_cases rw rw exact cases nomatch rwa


suffices simp_rw refine obtain exact rintro rw exact exact


refine induction zero succ intro obtain have rintro exact refine intro have simp exact obtain rw by_cases obtain rwa rw apply rw rw exact intro rw exact intro by_cases obtain rw exact rw exact rw simp rw all_goals


refine obtain refine rw rfl rintro exact


induction nil append_singleton ihp simp simp


rw refine simp intro refine rw refine gcongr exact simp


have rw rw refine convert change rw rfl rintro simp intro have rw simp


refine dsimp have rw refine apply apply exact rw exact


constructor rintro rw exact intro rw refine intro rcases use rw


simp simp_rw split_ifs rw intro rw intro apply rw intro rw split_ifs rw intro rw exact


rcases rw by_cases rw have rw refine rw split_ifs rw contrapose norm_cast rw exact rfl refine rw exact


ext rw split_ifs rw rcases exact have rw rcases rw rename_i rw exact


by_cases simp obtain set have have rw mul_comm rw rwa have exact le_antisymm


set conv_lhs rw rw nsmul_eq_mul] rfl intro rw zero_mul,


by_contra replace simp obtain rw rw exact


apply clear induction zero simp exact succ rw exact


rcases have contrapose rw exact by_contra have have have rw rootMultiplicity_mul lia


have rw contrapose simp rw refine refine rw contrapose rw simp exact


have contrapose exact rw natDegree_mul_leadingCoeff_inv simp


rw simp intro rw by_cases simp grind intro simp


ext simp by_cases grind rw by_cases rw rw rw


induction zero succ ext rw simp simp rw simp norm_cast congr rw congr have rw congr rw


ext simp monomial_eq_zero_iff, rw_mod_cast rw congr by_cases rw by_cases rw rw rw apply have have have push_cast rw rw simp field


classical rw refine simp_rw rw simp mem_support_iff, intro have grind simp


let let change simp congr clear ext simp have x monomial monomial intro rw subst by_cases simp by_cases simp rw mul_assoc rw rw congr rw_mod_cast


induction add monomial rcases rw have aesop aesop


subst rw simp homogenize_C_mul] refine rw congr obtain simp


apply intro simpa intro rw split_ifs simp exact


haveI calc degree have rw exact have have have calc degree rw exact add_le_add rw exact le_rfl rw


suffices refine exact rintro refine rw refine rw exact refine rw exact exact intro by_cases exact refine rw exact


have intro refine simpa exact exact have apply convert simp intro rw exact convert ext simp_rw rw intro rw intro rw


apply simp toFinsuppIso_apply] erw split_ifs rw lift apply rw ext have simp


refine rintro refine simp rcases exact refine simp


generalize revert refine intro rw exact intro have refine simp rw congr exact rw exact


refine ext simp simp_rw imp_false, exact


rw constructor intro obtain exact intro by_cases exact exact


rw intro by_cases use simp obtain use simp


rw let have let have have simp_rw mem_support_iff, exact exact


rw let have let have simp_rw hp.as_sum] have exact


by_cases rw nontriviality rw tsub_add_cancel_of_le rwa


by_cases rw by_cases rw exact rw rw rw by_cases rw revAt_le rw rw exact coeff_eq_zero_of_lt_natTrailingDegree


simp_rw refine exact intro rw rw rw exact exact intro use refine rw rw rw exact change rwa exact


constructor exact intro let have rw mul_assoc, have rw exact have rw exact have have rw exact have rcases exact exact exact exact


PolynomialModule.isScalarTower'

haveI inferInstanceAs constructor intro rw


simp smul_def] induction zero rw exact succ rw congr rw exact


induction zero add simp split_ifs exacts single rw grind


induction add rw split_ifs exacts monomial


induction add rw congr ext rw monomial f_a rw simp_rw simp


induction zero add single induction add monomial rw algebraMap_smul]


induction zero add single induction add monomial


nontriviality have rw rw exact have convert rw


revert refine simp rw rw rw exacts monic_multiset_prod_of_monic


simp_rw apply constructor rw exact simp_rw contrapose obtain exact exact


rw constructor rintro exact rintro exact


cases simp rw push_neg constructor rintro simp have rw use simpa rintro refine rw hm.coeff_natDegree, ring simp rintro simp


Polynomial.Monic.isRegular

constructor intro dsimp rw intro simp rw


refine rw intro rw simp rw intro rw refine simpa


constructor intro rw have ext simp refine rw rwa exact rintro simp


constructor intro replace simp rwa refine simp rintro rw


constructor intro rw rcases refine ext by_cases simp have rw exact simp rintro rw apply exact


set set have ext simp simpa have rw ext simp have rw ext simp rw


classical induction empty refine rintro insert obtain div_eq_quo_add_rem_div_add_rem_div hcop obtain refine intro dsimp split_ifs cases intro exact intro exact norm_cast rw trans push_cast ring congr refine grind


induction zero induction zero rw simp_rw revAt_add succ by_cases rw rw exact exact exact exact succ by_cases rw rw exact exact exact exact


refine simp intro simp conv rw intros simp


by_cases rw apply refine apply rw exact rw apply have rwa


obtain rw exact hp.not_isRoot_of_natDegree_ne_one


have refine rw dvd_cancel_right_mem_nonZeroDivisors exact rw exact


classical have have rw rootMultiplicity_eq_multiplicity multiplicity_mul


classical by_contra refine calc intro simp forall_exists_index, rintro exact


classical rw rw refine simp_rw exact exact


obtain use obtain rw subst simp constructor conv_rhs rw replace rw exacts


simp natDegree_le_iff_degree_le] constructor rintro by_contra have have refine rwa rwa rw rintro exact


classical ext rw split_ifs obtain simp refine exact


by_cases simp_all have rw rw rcases simp simp have by_contra suffices by_contra have grind simp obtain have obtain grind by_cases grind rw grind cases grind


rw simp have have grind rw congr funext simp


obtain have have rw have have rw exact have grind have rw trans grind exact have apply rw suffices suffices have grind coeffList_eraseLead, rw rw rw rw rw rw rw abel


have convert simp simp have apply simp have simpa coeffList_eraseLead,


have have have have obtain apply have generalize use constructor have have simp have simp have have by_cases suffices have we have grind suffices grind grind suffices have have grind suffices monomial monomial grind leadingCoeff_eraseLead_eq_nextCoeff] grind rw


obtain simp tsub_le_iff_right, rw split swap rfl rw split swap rfl rcases simp rw grind


generalize induction wlog simpa have have rw rcases have have dsimp rw simp generalize generalize have have have rcases obtain have simp hypothesis and true by_cases grind decreases most have simp leadingCoeff_eraseLead_eq_nextCoeff, have have rwa grind grind all_goals specialize have simp exact becomes grind becomes one, trans grind suffices simp grind


generalize induction exact rename_i have grind obtain grind obtain dvd_iff_isRoot.mpr grw exact simp


induction add intro simp monomial intro rw


induction add monomial rw smeval_monomial]


induction add monomial simp refine induction zero succ refine rw rw exact


induction add monomial simp refine induction zero succ refine rw have refine exact rw


have have rw simp_rw show dvd_iff_isRoot] refine rw apply


rw by_cases rw apply simp_all apply rw exact


refine let have rw obtain obtain choose have rw use rw apply simp rintro exact


nontriviality obtain rcases rw simp obtain rw rw simp have grw simp


rcases rw simp obtain rw refine simp rintro apply rw simpa


obtain by_cases simp obtain rw contradiction obtain exact


refine generalize generalize induction zero rw exact succ obtain have rw wlog exact obtain rw rw have aesop


refine obtain have have simp rw rw refine rw


refine rintro aesop classical by_cases simp obtain rw refine exact


have rw rwa rw simp_rw rw smul_mul_assoc, convert rw apply intro rw eval_sub,


have gp.natDegree cases inl use rw use intro rw inr obtain exact choose choose refine refine rw exact intro rw


rcases use rw use intro rw rw replace rw exact let have dsimp split_ifs exact rw have simp_rw exact refine refine rw exact intro have rw rw calc q rw exact rintro rw exact rw rw have rw congr apply exact rw rw intro exact rw intro rw exact


refine natDegree_eq_of_degree_eq_some replace rw rcases exact exact exact


obtain have rw rcases refine refine refine


refine obtain rw replace replace replace simp_rw rw rw rw simp_rw exact


rw refine rintro rw sum_insert sum_insert trinomial_middle_coeff simp_rw decide have refine rw exact


have rw simp_rw toFinsupp_monomial, rw simp rw simp rw exact refine rwa exact constructor rw exact grind exact exact exact


let replace replace replace rw rw simp rcases exact refine rw exact grind


have rw trinomial_leadingCoeff trinomial_trailingCoeff have rw simp rw simp rw mul_right_inj replace simp rcases exact rw rw rw exact irreducible_aux2


refine have obtain obtain have rw natTrailingDegree_mul_mirror, trinomial_natTrailingDegree have rw natDegree_mul_mirror, subst subst rcases rw rcases exact exact rw rw rw rw rcases exact exact


induction zero rw have have contradiction succ rw rcases assumption exact


induction zero rw exact succ obtain rw apply rwa


rcases exact obtain obtain have refine rw refine obtain rw exact


constructor exact simp rintro rw map_one] refine rw


simp constructor intro rw apply rw intro rw simp simp


constructor simp intro have rw simp ext intro rw exact


constructor intro rw by_cases simp aesop exfalso rw apply grind intro simp


rw have simp ring convert apply ext1 apply apply rw ext fin_cases


simp_rw generalize obtain specialize grind


rw obtain lt_trichotomy have tendsto_atBot_add_const_right rcases exact rcases simp have rw linarith have convert field


simp simp_rw simp simp simp simp simp simp simp linear_combination


apply rintro refine exact all_goals rw rintro all_goals


ext constructor intro induction rel induction of add_left mul_left mul_right refl symm trans intro induction of refl symm trans add mul


rw refine replace apply rcases exact simp


AddMonoidWithOne.ext

have have have have induction zero rewrite exact succ rw exact rcases congr


NonAssocSemiring.ext

have have congrArg have congr have congrArg have have cases congr


AddGroupWithOne.ext

have have have injection have cases ofNat negSucc rcases congr


NonAssocRing.ext

have have ext assumption have cases congr solve injection injection injection


Semiring.ext

have have have cases congr solve injection injection injection


Ring.ext

have have ext assumption field have congrArg cases congr solve injection injection


let change induction zero succ ih have dsimp rw have dsimp have rw add_comm have rw rw rw mul_add


induction zero succ simp split_ifs rw rw


by_cases by_cases rw exact have rw have rw refine rw exact


rw have refine rw congr rw lia rw simp_rw simp_rw rw sub_sub_sub_cancel_right


apply simp have refine have simpa simp convert


refine have have simp_rw have have simp_rw simp_rw exact rw convert simp


by_cases have obtain obtain simp_rw have simp


constructor intro rw intro simp contradiction exact


constructor intro rw intro rw contradiction exact


intro have obtain rw rw obtain exact exact


obtain induction zero succ have add_right_cancel calc a refine calc


apply refine rw refine change refine change exact rw rintro exact


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


rw induction mem obtain exact zero add obtain exact neg obtain exact hL.2


Subring.InClosure.recOn

have rcases clear induction nil cons rw suffices rw exact replace clear rsuffices rw clear induction nil cons rw rw exact rw clear induction nil cons rw rw exact induction nil cons rw rcases exact exact exact exact


apply intro rw obtain replace rw exact rw apply rw exact


ext refine rintro rintro refine refine exact


induction mem induction mem zero one mul add zero one mul add


constructor intro rw induction mem hx suffices let induction mem one mul obtain exact zero add obtain exact rintro exact list_sum_mem let ht2


have apply apply aesop rw classical let this let calc apply simp by_cases


classical simp apply simp_rw rintro exact


classical rw apply simp_rw rintro exact simp


rw have sum simp_rw rw congr ext rw simp_rw convert rw


refine rcases exact exact rintro simpa intro exact


by_cases obtain have replace rw exact exact exact


nontriviality obtain replace obtain rw exact


induction empty cons rw rw refine exact exact


induction zero unit mul obtain rcases exact by_cases exact suffices exact


classical rw haveI constructor by_cases have rcases rw rw assumption_mod_cast have contradiction simp rw intro rcases simp rcases apply rw exact_mod_cast


let have have have have rw simp have dsimp simp simpa apply simpa


have rw let let have dsimp simp simp simp simp abel_nf simp simp neg_smul, grind have have simp have simp have have positivity apply simpa


NonUnitalStarAlgebra.gc

intro rw coe_toNonUnitalSubalgebra] exact


RingQuot.Rel.star

induction of add_left rw exact mul_left rw exact mul_right rw exact


induction mem induction mem algebraMap mul add star algebraMap induction mem algebraMap mul add star mul add star


refine adjoin_induction_subtype exact simp simp simp simp


simp_rw simp_rw exact intro induction zero succ


induction nil cons rw simp_rw fst_list_prod, exact


ext rw simp simp simp_rw obtain simp obtain simp rw


rw constructor rintro exact exact rintro simp


let have have suffices preservesLimit_of_iso_diagram have suffices preservesLimit_comp_of_createsLimit exact


have simpa hx.preimage apply rw refine apply infer_instance


apply y.asIdeal.primeCompl convert delta congr simp rfl


refine letI have hU.isLocalization_stalk refine intro rw exact


trans trans refine intro apply_fun rw simp ext1 refine simp intro exact simp congr refine ext1 exact exact simp rw simp


letI letI refine exact exact have rw simp conv congr enter tactic change ext simp enter tactic change ext simp simp morphismRestrict_ι_assoc] simp rfl


apply rw exact intro obtain refine rw simp exact


classical have intro obtain obtain refine convert ext1 exact choose suffices obtain apply rintro obtain exact rw intro rw exact


refine let have obtain use simp symm exact rintro exact


suffices f.hom.comp g.hom.comp ext obtain simpa simpa ext1 exact simpa


change wlog refine intro have rwa obtain rw exact


constructor intro cases exact refine wlog obtain obtain exact this obtain have not_isEmpty_of_nonempty constructor intro have rw obtain h.2 have rw simp simp rintro


classical cases have exact have have let have obtain by_contra choose let have let pullback.map rw simp simp exact exact obtain exact let have have isAffine_of_isAffineHom have let have have let have apply have apply simp exact let exact this.map


let map f subschemeMap rw simpa map_id map_comp let haveI suffices simp infer_instance haveI haveI let π naturality let s suffices simpa refine simp fac uniq hm rw refine simp have simpa


by_contra obtain exists_mem_of_isClosed_of_nonempty simp exact exact


refine convert ext change refine change rw exact convert exact rintro convert exact simp rintro obtain dsimp rw rwa


have isCompact_iff_compactSpace.mp have rw exact obtain exists_map_eq_top refine replace simpa replace simpa


obtain obtain obtain refine simpa rw simpa


classical obtain have choose obtain replace refine simp exact simp sSup_eq_iSup']


wlog exact obtain wlog simpa this obtain obtain wlog let have have have have have this simp_rw simpa obtain obtain obtain let obtain have obtain simp simp exact


let by_contra let have obtain exists_mem_of_isClosed_of_nonempty refine use have simp


classical have let let let choose let rcases exact let let have obtain have trans exact exact refine apply intro let pullback pullback pullback.map have simp simp_rw rw


have have obtain exists_appTop_map_eq_zero_of_isLimit rw dsimp rw congr simp dsimp refine have convert congr dsimp rw congr simp simp


classical have have have obtain have obtain refine suffices rwa have simp convert convert congr simp dsimp change rw rfl choose dsimp have obtain obtain exists_app_map_eq_zero_of_isLimit dsimp simp simp_rw rfl) refine have apply_fun dsimp simpa choose obtain choose let have have obtain σ.attach.image₂ have hk have hk obtain exists_map_eq_top apply simpa have obtain simpa refine rw obtain this have change rw le_inf_iff] exact convert dsimp simp congr simp dsimp simp congr simp refine c.pt.presheaf.germ_ext have rw convert refine dsimp rw congr simp dsimp rw congr simp


classical have obtain obtain obtain obtain obtain obtain exists_map_preimage_le_map_preimage refine convert rwa change rwa choose obtain choose obtain replace obtain exists_map_eq_top refine change rw exact refine obtain use rw exact


have obtain have have obtain exists_map_eq_top have exact


classical obtain have isCompact_iff_compactSpace.mp have have obtain refine rw simp


classical have choose obtain obtain replace obtain exists_map_eq_top simp_rw exact refine refine simp_rw simp rw


AlgebraicGeometry.Scheme.affineCover

choose let exact f mem₀ rw refine change cat_disch


have let have intro have rw rcases exact exact f mem₀ rw exact


fapply intro simp refine simpa intro replace rw exact


choose have let have use apply on_goal simp exact


apply rintro exact rintro rcases let have rcases refine exact rw


refine wlog refine obtain obtain exact obtain obtain refine exact hU'.isCompact_pullback_inf simpa refine have simp_rw obtain simp_rw obtain exact


by_contra rcases simp apply_fun rw apply rcases iterate iterate


rw by_cases have rcases rw rw rw replace ext rfl simp ring1 simp ring1 linear_combination rw rw simp grind


classical nontriviality rw finCongr_symm_apply,


have by_cases have rcases simp simp ring1 nth_rw simp rw apply simp ring1


have rw rw simp_rw rw simp_rw rw span_pair_add_mul_right apply convert simp_rw mem_map_iff_of_surjective by_cases have rcases let replace refine rw simp linear_combination replace refine rw simp ring1


have have grw have rw rw by_cases simp exact by_cases simp exact rw rcases exact rw rcases exact rw rcases convert rw exact rw convert rw exact


rcases any_goals rw rw constructor contrapose exact exact


constructor intro rcases rfl rcases apply rw exact


induction nat neg simp_rw rcases push_cast rw


have rw have rw haveI rw exact obtain obtain obtain have rw exact use ext simp_rw ring1 simp_rw show ring1 simp_rw a₁_of_isCharTwoJEqZeroNF, simp simp linear_combination simp linear_combination


obtain obtain simp_rw inv_inj] obtain use rw have rw exact obtain have rw exact obtain use rw


obtain obtain rw obtain use rw have rw exact obtain have rw exact obtain use rw


replace replace haveI haveI have norm_num1 exact haveI have norm_num1 exact letI letI wlog obtain rw obtain exact wlog obtain rw obtain exact simp_rw replace letI invertibleOfNonzero have norm_num1 exact rw linear_combination by_cases have rw pow_ne_zero_iff replace have rw exact have rw pow_ne_zero_iff replace obtain have rw exact use ext simp simp simp simp simp_rw simp by_cases have rw pow_ne_zero_iff replace have rw exact have rw pow_ne_zero_iff replace obtain have rw exact use ext simp simp simp simp_rw simp simp have rw pow_eq_zero_iff simpa have rw pow_eq_zero_iff tauto obtain have rw simp linear_combination have rw simp linear_combination have rw exact use ext simp simp simp simp_rw simp simp_rw simp


obtain by_cases subst exact by_cases subst exact exact


have have have have simp use simp hQz, conv_rhs congr rw hQx.inv_mul_cancel_right] rw hQy.inv_mul_cancel_right]


revert refine by_cases rw exact rw smul_eq


have letI rw set haveI constructor simp simp have simp linear_combination


constructor simp simp linear_combination simp linear_combination


use ext all_goals apply apply apply apply apply


let let let have have by_cases use apply all_goals simpa have have let have use have simpa choose have by_contra exact use apply all_goals apply simp sub_zero, apply simp refine refine any_goals apply linarith rfl


obtain exists_maximalFor_of_wellFoundedGT refine intro let simp_all rw exact


refine simp have not_iff_not.mpr refine simpa


refine obtain rw intro replace have rw erw exact exact have rwa


apply convert symm rw convert rw apply exact


haveI delta convert genericPoint_eq_of_isOpenImmersion apply exact


haveI haveI delta convert hU.isLocalization_stalk rw ext


have refine rw constructor intro ext exact apply


simp have symm rw erw erw simp_rw rw simp


apply intro obtain obtain refine constructor simp exact infer_instance


intro obtain obtain rw simp_rw rw let rw use constructor erw rfl erw rfl


intro rw intro rw use use constructor rw apply convert simp congr exact exact


refine fapply exact rintro dsimp change simpa


have have exact have simp rw convert simp


constructor rintro obtain obtain rw simp glueDataι_naturality] refine dsimp rintro obtain refine obtain apply simp trans simp simp


obtain use apply simp_rw congr have simp


rw intro obtain have rw apply_fun simp simp


intro have intro obtain exact choose have rw exact have refine rintro dsimp simp erw delta rw rw exact


rw refine apply rintro simp intro obtain have have rw obtain apply_fun refine cases


simp trans refine obtain exact refine rw