rw rcases apply convert exact convert rw exact simp have refine rw refine rw suffices convert conv_rhs rw simp_rw suffices convert suffices convert rw suffices conv convert rw exact simp


have refine convert simp_rw rpow_def_of_neg rw


by_contra set deriv have apply intro simp field_simp nth_rw simp exact


rcases exact replace apply exacts continuousAt_const.mul


induction zero succ have rw rw simp exact


apply induction zero succ simp ext simp grind


have have intro rw simp set have filter_upwards intro exact have have rw congr rw have exact


have intro rw exact rcases exact simp rw exact


cases top rcases simp mul_neg_of_neg_of_pos, coe by_cases rcases simp mul_neg_of_neg_of_pos, have simp


rcases replace wlog convert rcases induction rcases exact induction rcases induction rw rcases simp norm_cast rw norm_cast


classical induction empty insert have rw apply


lift by_cases rcases simp linarith rw simp


rcases cases top coe by_cases simp simp simp cases simp simp


by_cases simp by_cases rw have simp rw exact


induction zero obtain simp succ rw split_ifs grind have replace grind


induction zero succ rw split_ifs rcases grind exact assumption


cases inl simp refine gcongr inr simp refine gcongr assumption


constructor intro simp by_cases subst simp exact rw exact rintro exact exact


rcases by_cases simp calc mul_le_mul simp simp


rcases rw refine filter_upwards rw rw refine simp have convert simp ring filter_upwards simp


apply induction zero succ rw refine convert exact


Real.smoothTransition.monotone

intro simp rw simp gcongr exact exact apply apply


rcases rw have exact contDiffAt_const.congr_of_eventuallyEq have constructor simpa exact


let change rw convert ext dsimp rw push_cast field have simp cast_succ, ring


have have have simp_rw exact rw exact have refine rw exact exact


let use let intro have convert have have exact calc log


refine have rw simp rw exact tendsto_self_div_two_mul_self_add_one


have nth_rw rw apply congr rw coe_two_pi]


constructor intro rw sin_eq_zero_iff, rcases right rw rw zsmul_zero] left rw rw rw rintro rw sin_int_mul_pi, rw mul_comm


constructor intro rw rcases left rw exact right rw sub_eq_zero] exact rw rintro rw sin_int_mul_pi, have rwa rw cos_add_pi_div_two,


rcases rcases rw obtain rw eq_false have rw exact


intro induction induction simpa eq_comm]


nth_rw constructor rintro simp intro rw have exact


induction induction rw rcases rw eq_sub_iff_add_eq', rw exact


have refine rintro simp rw contradiction


rw constructor intro rcases exact have rw have aesop intro aesop


rcases simp_all rw suffices rw rcases rw have fin_cases all_goals


rw have obtain obtain have grind obtain grind simp_all abs_of_pos] obtain grind


obtain obtain have convert all_goals grind exact


refine simp rw rintro rcases rw refine rw simp rw refine rw have rw norm_num assumption_mod_cast exact


rw congr conv_rhs exact rw rw exact exact


have have simpa have rw sub_eq_iff_eq_add', grind


rw congr rw exact refine positivity exact


have have congr ring linarith rcases linarith have linarith


set set set suffices have rw push_neg intro replace lia suffices calc s


set have rw exact have rcases simp absurd rw exact


simp mul_comm have apply_abs_le_add_of_nonneg refine exact refine exact


rcases exact have have rw apply rw refine apply simp


wlog simpa rw have have ring_nf linarith


have have rw refine have rw refine apply simp


let have have have exact have rw exact have apply intro simp exact have have have simp norm_cast have apply rw simpa rwa exact simpa have have have simpa


suffices rcases exact convert rw rw intro have rcases have rw abs_of_nonneg lt_one_div sq_lt_sq, exact refine exact


rcases simp refine apply exact rw rw nth_rewrite exact


rcases simp have rw have have have rw exact


rw refine calc negOnePow_mul_negOnePow_mul_cancel.symm


refine rw apply apply rw rw replace contrapose obtain obtain replace suffices have refine rw exact refine have grind


simp_rw have rw grw norm_cast simp convert exact simp


by_cases simp lift replace rw grw norm_num


refine apply suffices replace rwa lift contrapose rw positivity replace contrapose have calc


rw integral_withDensity_eq_integral_smul congr simp


have suffices rw simp_rw rwa trans refine by_cases rw rw simp exact


constructor intro obtain use refine rw exact rintro rw norm_cast


wlog simp refine refine field_simp norm_cast grind


wlog simp refine obtain rw use field_simp norm_cast rw exact


refine apply intro field_simp aesop refine field_simp norm_cast grind


wlog simp refine obtain suffices refine field_simp norm_cast grind rw use field_simp norm_cast ring rw exact


have have calc k refine intro dsimp rw exact rw exact rw exact


have have have calc k refine intro dsimp rw refine rw exact rw exact


constructor intro replace rw mul_eq_zero_iff_left replace hx rw obtain refine rw congr exact rintro rw exact


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


rw obtain have suffices field_simp apply contrapose have calc have rw_mod_cast


have rw neg_eq_neg_one_mul, ring_nf rw refine refine ring


rw constructor rintro use simp ring rintro use simp ring


rcases rw div_div_div_cancel_right₀ simp div_self haveI obtain simp rw mul_div_assoc,


have tan_add rcases refine rw convert push_cast ring refine rcases use push_cast ring rw convert ring


intro obtain rcases refine rintro simp refine rw convert ring


rw constructor rintro exact exact rintro obtain exact exact


rw have rw ring_nf have ring_nf rw ring_nf rw field


have π simp ring rw geom_series_mul_one_add ring


have obtain refine simpa simp norm_div, intro gcongr apply


have rw logDeriv_div logDeriv_comp deriv_id'', ring simp simp exact


have have have have rw aesop simp deriv_div_const, field


rw apply suffices rw simpa suffices apply simp


intro rw have have simp rw ring simpa simpa


have intro have convert ring convert integral_mul_deriv_eq_deriv_mul ext1 rw refine ring apply apply


have x intro have convert simp simp rw congr rw have rw ring convert refine ring_nf rw zero_sub, rotate_left apply apply exact refine dsimp rw mul_div, congr have conv_lhs rw ring apply apply


rw have have rw congr nth_rw nth_rw rw refine rw nth_rw nth_rw rw refine rw


rcases simp induction zero simp_rw rw zero_div, simp succ rw set set set have have rw dsimp rw sub_zero, rw change π have π rw suffices rw have have convert simp have simp convert rw


have atTop have simp_rw convert suffices atTop from have convert ext1 rw


convert ext1 rw suffices rw rw refine norm_cast rw


by_cases rw rw nlinarith by_cases rw rw nlinarith have rw sqrt_mul_self rw


rw by_cases have rw simp by_cases have rw simp rw


by_cases rw rw nlinarith by_cases rw rw nlinarith rw


refine rintro have filter_upwards have simpa


rw have replace dsimp simp_rw refine dsimp convert rw simp_rw neg_div,


rw have replace dsimp simp_rw refine dsimp convert rw simp_rw zero_add, mul_div_cancel_left₀


rcases rw ring_nf rw exact simpa simp rw exact


induction zero succ rw congr rw congr ring


convert exact simp have rw refine simp_rw refine have rw refine intros simp_all


apply exact refine intro dsimp field apply all_goals apply apply exact


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


refine lift refine exact rw norm_cast exact


refine contrapose intro specialize simp obtain exact intro have simp simpa


rcases rcases norm_cast convert rw rw refine calc


posSumOfEncodable

let have have refine rcases refine intro exact intro exact


classical haveI rcases refine conv_rhs split_ifs exacts simpa


lift rcases have refine refine rw refine grw


have rw apply refine simp have linarith refine rw simp


have rw apply refine rw exact refine simp


and to of have rcases have apply gcongr exact have intro rcases have rw filter_upwards have calc u gcongr refine simpa obtain eventually_atTop.1 let filter_upwards have rcases exact let have have by_contra have apply apply exact exact have have have simpa have have apply rw exact have have rwa calc u gcongr exact linarith have intro rcases have rw filter_upwards have calc gcongr refine simpa obtain eventually_atTop.1 let filter_upwards have rcases exact let have have by_contra have apply apply exact exact have have apply rw exact have have simpa calc gcongr exact gcongr have simpa refine obtain have apply exact simp exact filter_upwards simp_rw calc d rw linarith exact obtain have apply exact simp exact filter_upwards calc u


apply intro obtain refine hc have intro refine simp have refine refine exact refine exact have simp convert ext1 field filter_upwards exact


have have have rw swap exact have simp rw simpa have calc gcongr intro simp simp apply apply rw exact gcongr exact rw exact have apply rw rw simp field rw simp ring


have have calc gcongr rw apply refine simp exact rw gcongr rw exact rw gcongr exact congr field


have obtain have suffices this.trans_isLittleO conv suffices intro rw refine simpa


by_cases refine simp rw have isLittleO_pow_const_const_pow_of_one_lt suffices simpa exact


refine rw apply filter_upwards induction base succ


by_cases rw simp refine have refine convert simp linarith simp nontriviality have have linarith


rcases rw apply calc apply filter_upwards simp apply have exact simp exact


induction zero succ ih have apply apply filter_upwards simp norm_cast calc convert hasSum_sum_range_mul_of_summable_norm n have apply simp rw simp rw


refine obtain let refine have have have have simp conv_lhs simp have apply apply simp_rw simp exact convert ext simp


have convert simp have convert ext simp symm calc simp


set have have intro simp apply exact intro simp split_ifs rw exact push_neg exact


rw rcases rw rcases rw refine convert refine intro specialize simp exact grind


have filter_upwards rw linarith rcases refine filter_upwards rwa


rw simp_rw apply refine refine cauchySeq_range_of_norm_bounded simp_rw apply simp_rw exact rw exact


have refine rw simp_rw sub_le_iff_le_add] gcongr exact exact


have refine rw simp_rw sub_add_eq_add_sub, gcongr exact exact


have refine rw simp_rw le_sub_iff_add_le] gcongr exact exact


obtain have have have apply filter_upwards obtain obtain specialize specialize simp rw constructor rwa rw exact obtain specialize specialize rw rw constructor rw exact simpa


have have suffices summable_of_ratio_norm_eventually_le intro calc rw


obtain refine filter_upwards hf.eventually_ne_cobounded rcases simpa calc


apply dsimp simp_rw apply change simpa rw exact


refine have have rw refine simp refine rw refine simp gcongr apply


refine refine obtain rw rcases rcases exact exact


have rw apply rintro simp exact calc gcongr apply exact rw intro exact


have intro refine rw apply simp simp simp calc convert simp apply have refine apply simp and_self_iff] refine simp


rw conv congr congr skip skip rw skip skip congr congr rw rw conv rhs congr skip ext rw apply simp


have intro refine rw apply simp simp simp calc apply have refine apply refine simp refine simp convert simp


rw conv congr congr congr rw skip skip skip rw rw conv lhs congr congr skip ext rw apply simp


apply intro simp have simp norm_cast lia have simp exact have refine norm_cast lia apply apply simp exact exact exact apply simp refine norm_cast lia exact simpa apply apply apply apply exact apply apply exact apply intro apply simpa simpa simpa


apply intro simp have simp norm_cast lia have simp exact have refine norm_cast lia apply apply simp exact exact exact apply simp refine norm_cast lia exact simpa apply apply apply apply apply apply exact apply intro apply simpa simpa simpa


trans rw simp let have have intro contrapose exact convert simp le_add_iff_nonneg_left,


intro have simp obtain specialize contrapose have rwa


by_cases rw have simp rw exact hs.of_nonneg_of_le hf obtain exact


let parallelPair.ext refine let refine change rw


rw intro obtain have obtain this.exact_up_to_refinements obtain simp


apply intro have rw obtain dsimp have obtain obtain have rw rfl rw


rw intro obtain have rw comp_zero, obtain dsimp have rw obtain dsimp rw obtain refine rw dsimp rw


dsimp have apply dsimp infer_instance have apply infer_instance apply


let homMk₃ refine mono_of_epi_of_mono_of_mono dsimp rw exact rw exact


let homMk₃ refine epi_of_epi_of_epi_of_mono rw exact dsimp rw exact


let homMk₃ refine mono_of_epi_of_mono_of_mono rw exact


let homMk₃ refine epi_of_epi_of_epi_of_mono rw exact


constructor rintro let exact rintro have let exact


rw have simp constructor intro exact intro rw apply


rw constructor intro apply intro infer_instance


rw dsimp apply obtain kernel.lift obtain cokernel.desc rw


apply intro let τ₂ τ₃ comm₂₃ dsimp rw apply apply exact


apply intro let τ₂ τ₃ comm₁₂ dsimp rw apply apply exact


refine rw refine dsimp rw ext obtain rfl


ext dsimp dsimp simp erw erw conv_lhs rfl


let naturality g dsimp simp have exact colim.map_mono


have obtain exists_isIso_of_functor_from_monoOver dsimp refine simpa


refine refine dsimp ext rw apply refine exact


rw simp obtain refine intro rw obtain exact exact


induction obtain refine refine dsimp simp


obtain have letI exact preservesColimit hf let map_mem hj have simp refine simp exact have apply obtain exact


refine rw trans apply apply apply apply apply simp


refine dsimp classical rw refine rw simp let suffices simp suffices simp simp simp


let epiDesc let refine simp conv_lhs simp


haveI apply rw intro induction let naturality f dsimp simpa exact rw intro exact


let colimit.desc naturality haveI have rw refine rw dsimp rw apply


have have rw let have rintro exact obtain have refine rw intro let trans exact exact


refine have simp exact obtain exact exact


generalize induction bot simp exact coe induction top by_contra simp obtain rw exact coe simp exact


have ext have simp rw congr rw congr simpa


rw dsimp rw erw obtain rw dsimp simp rfl


let monoIsKernelOfCokernel apply intro have obtain rw have erw haveI apply rw


have let refine intro apply intro haveI apply convert apply let apply intro have obtain rw have rw change rw apply rw


rw conv_lhs rw conv_lhs congr skip rw rw


simp simp cokernelIsoOfEq_hom_comp_desc_assoc, simp rw


have ext have φ.hom'.f simp rw congr simp


intro refine apply have have exact simp exact


intro have have have rw exact have apply dsimp rw apply


obtain refine obtain obtain refine dsimp rw obtain obtain refine dsimp rw


constructor intro exact intro obtain rw exact


rw constructor intro obtain exact intro obtain exact


dsimp have simp have comp_id rw assoc, erw rfl


refine change refine intro dsimp refine exact exact rw simp simp exact change refine intro dsimp refine exact exact simp simp simp


CategoryTheory.abelianOfAdjunction

haveI haveI have intro let have let rw infer_instance apply


rw let have have let have apply exact simp infer_instance suffices exact simp


change have inferInstanceAs infer_instance


change have constructor intro infer_instance apply


induction zero succ refine induction simp_all id_tensorHom, tensor_ρ, simp


induction zero funext simp succ funext induction simp_all leftRegularTensorIso_inv_hom, simp_all


constructor intro refine have rw exact refine rintro exact exact exact constructor rintro rw exacts intro introv refine rotate_left rintro dsimp exacts ext simp exacts rintro dsimp exact exacts constructor intro rintro dsimp exacts exact


constructor rintro refine intro dsimp refine apply rw rw intro apply dsimp rw refine refine fapply exact intro rw erw erw rfl intro intro apply symm rw apply erw erw rw rfl refine


obtain introv obtain hg.w.symm refine refine dsimp constructor rintro refine let let have have rw obtain e₂.symm).mpr constructor apply rw apply rw rw apply have apply exacts rw exact rintro exact


constructor intro rw apply intro refine refine refine apply


apply intro rw refine refine refine refine apply


have have apply intro have rw refine refine exact exact


refine intro specialize choose let have intro obtain exact obtain apply


obtain obtain apply simp rw conjugateEquiv_associator_hom


constructor intro exact rintro rw infer_instance


refine intro rw dsimp erw erw simp_rw cat_disch


let rsuffices let refine exact let refine exact let intro simp exact exact


refine intro rw dsimp simp erw simp erw simp


unfold ext simp id_obj, slice_rhs rw slice_rhs rw rw rw slice_rhs rw rw simp slice_rhs simp slice_rhs simp


ext dsimp have mateEquiv_vcomp have simp associator_hom_app, map_id] rw


ext have unfold have simp whiskerRight_comp, associator_inv_app, whiskerRight_twice, simpa


ext have unfold have simp leftUnitor_hom_app, simpa


refine ext simpa leftAdjointObjIsDefined_of_adjunction


refine ext simpa rightAdjointObjIsDefined_of_adjunction


simp_rw dsimp simp simp_rw rw refine rw simp_rw refine rw simp


let haveI have refine rw apply haveI exact


let constructor intro let exact intro let exact


simp symm calc r₁ r₁ h₁ r₁ rw bicategory r₁ rw bicategory r₁ r₁ r₁ rw bicategory r₁ r₁ r₁ rw bicategory rw bicategory


simp dsimp calc r₃ r₃ r₃ r₃ r₃ r₃ r₃ rw bicategory rw bicategory


simp calc rightAdjointSquare.vcomp dsimp bicategory rw simp bicategory


symm calc rightAdjointSquare.vcomp dsimp bicategory rw simp bicategory


ext simp eqToHom_comp_heq_iff, conv conv iterate simp


rcases apply clear induction vcomp whisker_left whisker_right


rcases induction id vcomp simp slice_lhs slice_lhs simp whisker_left dsimp rw simp whisker_right dsimp rw have dsimp simp


calc bicategory rw bicategory rw bicategory


calc bicategory η.app rw bicategory η.app rw bicategory rw bicategory


ext rw rw erw rw simp rw dsimp simp simp


ext rw dsimp rw rw rw dsimp simp rw simp rw rw simp


partialFunToPointed

classical exact map map_id funext dsimp convert map_comp funext dsimp rw


constructor intro exact rintro rw infer_instance


induction induction obtain induction nil cons


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


let let let haveI haveI cases fconstructor haveI obtain use intro have simp simp_rw


intro obtain obtain refine rintro refine have rwa


constructor intro refine have dsimp rw rw rintro simp rw


constructor intro refine have apply have change congr) apply rintro have infer_instance


rw intro let colimitIsoColimitGrothendieck convert apply intro simp change simp


let let let let let let map have apply exact


fapply intro dsimp simp exact intro dsimp simp


rw intro have inferInstanceAs let calc colimit colimit grothendieckPrecompFunctorToComma convert simp rw apply


let let let let let have dsimp let let map₂ pre apply have exact have apply exact isoWhiskerRight


suffices rw infer_instance ext simp exists_prop] exact


obtain obtain obtain cases obtain dsimp rw obtain simp simp rfl obtain simp simp dsimp rw obtain simp obtain simp dsimp rw


have intro rcases exact exact exact rw dsimp rw this


obtain obtain obtain obtain obtain obtain obtain rfl


induction zero succ obtain refine obtain simp exact


constructor intro constructor rintro rw rw exact intro apply intro have change rw infer_instance


CategoryTheory.instIsConnectedComponent

apply rintro have rcases let have intro apply intro apply apply refine refine exact


apply_fun ext simp rw simp apply_fun ext simp simp rw simp rw apply apply_fun rw simp apply_fun simp simp rw simpa


dsimp ext have dsimp simp congr simp rfl


rw dsimp rw slice_lhs slice_lhs slice_lhs slice_lhs dsimp rw dsimp rw dsimp rw slice_lhs dsimp rw slice_lhs slice_lhs rw dsimp rw dsimp rw slice_lhs slice_lhs dsimp simp


fconstructor intro fconstructor rcases refine exact infer_instance rintro let exact


let refine rintro obtain simp obtain obtain rfl


refine small_of_injective exact have rw tauto


let let have apply rintro rintro clear_value subst exact


refine constructor simp_rw intro obtain rw obtain rw


CategoryTheory.types.finitaryExtensive

classical rw apply intro constructor refine intro have intro rcases simp apply_fun cases delta choose exact funext refine intro have intro rcases apply_fun cases simp delta choose exact funext intro dsimp delta have intro rcases exacts let let ext fapply exact intro ext dsimp split_ifs intro ext dsimp split_ifs cases rfl intro ext split_ifs rw rfl rw rfl


have apply rintro rintro have apply rintro rintro refine refine convert refine convert convert


rw apply intro constructor refine intro have intro rcases exact apply_fun cases delta choose refine apply convert exact refine intro have intro rcases apply_fun cases exact delta choose refine apply convert exact intro exact


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


constructor intro refine have rcases refine


let have clear_value subst induction zero succ refine dsimp infer_instance


let have clear_value subst induction zero succ apply apply apply exact apply exact dsimp infer_instance


classical let have clear_value subst change obtain let inv hom_inv_id inv_hom_id ext simp simp dite_true, exact let have simp exact clear_value rw have exact


let pullback.map apply refine exact exact exact


convert coproductIsCoproduct ext simp ext simp exact exact


refine have exact fac_left rw congr rw fac_right


subst_hom_lift let use have refine have rw apply apply simp


constructor intro subst_hom_lift obtain h let let use refine simp intro rw apply simp


classical induction empty insert obtain use rintro obtain exact exact


classical induction empty obtain exact insert obtain obtain refine intro rw by_cases rcases grind rw apply contrapose obtain trivial


classical let let obtain refine intro dsimp simp apply simp exact


have obtain exact have refine intro obtain exact intro obtain refine have have simp_all apply


classical let let obtain refine intro dsimp simp symm apply simp exact


refine let haveI simp exact refine lim.map colim.map exact


have obtain exact suffices refine obtain h₂ refine exact exact refine simpa


suffices suffices apply intro obtain exact intro obtain exact


have apply subsingleton obtain refine conv_rhs dsimp simp


refine intro obtain exact let let have intro obtain exact


refine obtain refine intro obtain exact intro obtain exact


classical apply exact intro let refine dsimp rw simpa


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


we we have of let have let exact have obtain exact cocone_objs rintro obtain exact cocone_maps rintro obtain exact let map have exact inferInstance, have obtain let exact the let obtain exact


refine rintro exact rintro refine conv_rhs apply refine simp


refine small_of_injective_of_exists rintro induction base refine simp exact simp rw rfl max rcases rcases refine simp refine all_goals exacts simp rw rfl coeq rcases rcases refine simp refine all_goals exacts simp rw rfl


refine small_of_injective_of_exists rintro induction base refine simp exact simp rw rfl min rcases rcases refine simp refine all_goals exacts simp rw rfl eq rcases rcases refine simp refine all_goals exacts simp rw rfl


constructor intro have rw infer_instance intro infer_instance


CategoryTheory.RepresentablyFlat.comp

refine obtain let map obtain simp exact simpa


refine suffices apply suffices suffices apply


let let let let let let let have intro injection injection convert have unfold congr ext apply have calc g₁.right apply aesop symm apply aesop calc f₁


apply intro intro intro constructor exact fac uniq apply exact exact


obtain unfold have subst congr simp ext exact


constructor intro rw infer_instance intro rw infer_instance


constructor intro rw infer_instance intro exact


letI let refine ext haveI haveI dsimp simp dsimp ext1 apply apply ext dsimp have have have dsimp simp const_obj_map, whiskerLeft_app, simp apply


letI let haveI simp const_obj_map, refine apply ext have simp simp dsimp ext1 apply ext have have simp simp apply


revert suffices from intro change infer_instance


revert suffices from intro let let exact


induction zero induction zero succ obtain lia obtain rw simp rw obtain all_goals succ rcases lia lia lia exact hi


rw haveI change infer_instance haveI change infer_instance exact


induction intro by_cases exact by_cases obtain obtain let have rw exact have have rw exact have rw exact let let refine use refine cases exact exact simp obtain exact


subobject let let let let let let have have have use have have rw change simp


apply intro convert_to simp dsimp rw convert_to rw rfl


obtain use use constructor refine obtain obtain use change simp rw exact refine intro use exact


let letI have let let rw change exact rw change exact have ext exact exact


obtain letI haveI have let let let let have ext exact have let change have rw exact rw exact have obtain let exact choose exact


obtain haveI haveI have obtain obtain let let have have have refine induction change apply apply simp exact simp have intro ext let have obtain simp have have exact colimit.isoColimitCocone


obtain obtain have obtain connected_component_unique refine apply evaluation_injective_of_isConnected suffices exact


obtain let choose let let have simp rw refine suffices simp refine exact


let let preservesColimitIso apply apply exact


let obtain refine exact apply simp intro apply simpa


intro let obtain obtain obtain use apply simp


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


intro choose let let have rw apply intro apply exact intro rw obtain use simp intro rw inv_smul_smul] obtain refine ext simp have simp exact obtain rw exact


refine refine intro obtain obtain refine simp intro obtain refine apply change rw


obtain have refine obtain obtain have obtain use rw change rw


obtain obtain choose refine rintro obtain exact refine suffices rw exact have have ext obtain rw simp exact


haveI haveI let refine refine suffices let let let section_ let exact zero_of_comp_mono rw comp_zero])


refine refine obtain exact refine obtain refine exact


constructor intro rw intro exact intro refine exact intro rw


have haveI haveI letI suffices exact have refine let exact suffices intro suffices exact ext simp⟩


suffices refine have refine simp simp factorThru_arrow]


refine convert ext simp constructor rintro rintro


let refine isSeparator_of_isColimit_cofan exact


rw refine obtain exact obtain replace choose exact


rw refine suffices obtain exact obtain choose let naturality refine dsimp rw


delta simp_rw rcases rw show rcases exact simp rfl⟩


apply apply let cases exacts apply apply refine rintro all_goals


CategoryTheory.instHasPullbackF'

apply simp infer_instance apply simp infer_instance have convert


dsimp rw mapTrifunctorMapNatTrans_app_app_app] erw


let have let have let have let let let invFun left_inv obtain rfl let refine refine obtain rfl have refine dsimp rw rfl


rw ext simp congr rw ι_mapBifunctorAssociator_hom_assoc, ιMapBifunctorBifunctor₂₃MapObj_eq_assoc ι_mapBifunctorMapMap] dsimp rw ι_mapBifunctorLeftUnitor_hom_apply ι_mapBifunctorRightUnitor_hom_apply dsimp simp congr symm apply


fapply intro rfl intro simp eqToHom_trans_assoc,


constructor rw intro simp infer_instance intro exact


rintro have constructor constructor simpa


apply induction nil cons simp fapply exact apply apply have apply apply simp change simp exact exact


apply apply fapply rw exact rintro simp change have convert


constructor rintro suffices simpa apply exact


constructor rintro ext apply rintro refine obtain exact


constructor rintro have rw exact rintro apply exact


dsimp constructor rintro change obtain exact rintro exact


constructor rintro exact rintro simp exact


rw intro have have have dsimp infer_instance


rw intro let let have have apply intro exact


constructor intro let let have rw infer_instance intro infer_instance


rw intro let structuredArrowDownwards w.structuredArrowDownwards dsimp simp rw infer_instance


constructor intro have ext simp rw exact intro exact


constructor intro letI have letI let let let have ext simp simp simp rw simp rw infer_instance intro exact


constructor intro rcases exact isLimit apply intro refine constructor simp intro rw rw simp exact intro refine intro haveI refine equalizer.lift_ι ext simp rw


rw constructor intro haveI convert rw intro haveI apply


constructor exact apply rw slice_rhs simp


refine intro let erw slice_rhs rw rcases use constructor rw simp rfl


refine intro rcases use constructor simp rfl simp rfl


refine have haveI hC the let map equalizer.lift let naturality let naturality use constructor ext dsimp rw ext simp


apply intro ext simp intro apply intro ext simp intro rfl


apply intro specialize induction refl tail rw rcases exacts


constructor intro have exact intro exact


simp constructor intro obtain exact intro exact


CategoryTheory.finBiconeHom

cases exact complete exact complete exact complete exact complete exact complete exact complete exact complete exact complete exact complete rcases simp use simpa


classical obtain rw obtain obtain simpa congr rw


suffices limMap hc.conePointUniqueUpToIso ext simp limit.conePointUniqueUpToIso_hom_comp] congr simp


isPullbackOfIsTerminalIsProduct

apply intro use use use intro apply rintro exact exact


let let haveI have intro refine let let let have rw apply rw haveI rw apply exact


constructor intro simpa intro constructor intro obtain rw


rw constructor intro obtain refine simp simp intro obtain have rw


classical cases intro obtain obtain dsimp replace simp simp curry_obj_obj_map] let let let have let have have have let obtain have simp refine simp have simp refine simp apply colimit_sound ext simp rw simp


classical intro have jointly_surjective let let have clear_value clear let have clear_value have colimit.ι colimit.ι intro nth_rw simp rw simp simp_rw let let let have have dsimp simp_rw convert clear_value clear let have have let obtain let have intro rw exact exact rw heq_eq_eq, eq_self, trivial⟩⟩⟩ exact rw heq_eq_eq, eq_self, trivial⟩⟩⟩ clear_value clear fconstructor apply dsimp apply swap exact dsimp intro simp calc rw rw rw apply intro simp types_comp_apply, refine rw types_id_apply]


have suffices apply infer_instance apply


apply intro refine symm trans exact exact


refine obtain obtain let let let obtain obtain dsimp have intro have have dsimp rw obtain refine conv_rhs simp choose apply exact have choose refine refine have exact


CategoryTheory.Functor.Final.induction

apply apply intro fapply convert simp intro fapply convert simp


apply intro rw rw simpa intro rw rw simpa exact


induction rel obtain fconstructor swap fconstructor left exact refl symm apply exact trans apply exact exact


let let let let isoWhiskerLeft rw final_iff_isIso_colimit_pre] rw rw intro rw infer_instance


let let let let isoWhiskerLeft rw rw rw final_iff_isIso_colimit_pre] intro replace rw exact


constructor rintro let letI apply rintro dsimp apply refine exact zigzag_prefunctor_obj_of_zigzag


let let let let have inferInstanceAs have dsimp have mapWhiskerLeftIsoConjPreMap isoWhiskerLeft have rwa final_iff_comp_equivalence]


refine ext let have have have dsimp rw have constant_of_preserves_morphisms intro dsimp rw dsimp rw choose refine let simp ext simpa


refine have constant_of_preserves_morphisms intro ext dsimp rw choose let ι ι_naturality f ext have rw simp refine obtain simp obtain let exact


refine let let let refine refine exact exact


refine obtain nonempty_indParallelPairPresentation exact


obtain let let obtain refine let let exact


refine have obtain obtain let isColimitOfPreserves obtain yoneda.obj exists_nonempty_limit_obj_of_isColimit have let obtain exact


have refine have choose refine obtain let obtain refine simp exact refine refine simp


rw refine iff_of_iso all_goals simpa simpa simpa simpa


dsimp simp apply intro rw simp rw simp rw ext simp


constructor intro exact preservesColimits_of_natIso rintro apply intro dsimp apply let functorToRepresentables. refine exact


have uliftYonedaEquiv.injective have congr_fun have have dsimp apply dsimp rw simp simp


ext apply apply intro have have have dsimp simp congr simp apply dsimp rw


apply suffices apply apply refine apply exact apply let isColimitOfPreserves exact


ext simp simp simp simp simp simp simp simp


constructor intro have rw rw intro exact


constructor intro simp simp show rintro rw apply apply apply


constructor rintro obtain exact intro exact


fapply exact simp simp intro apply simpa simpa


constructor rintro obtain refine rw have rwa intro exact


fapply exact simp simp intro apply rw simpa simpa


refine let let exact let let exact apply apply exact apply apply exact


classical ext dsimp simp dsimp rw split_ifs subst simp


classical have ext simp ι_π_assoc] split all_goals rw infer_instance


simp ext by_cases subst simp simp rw simp rintro simp exact


simp ext by_cases subst simp eqToHom_comp_ι, simp rw simp exact rintro simp


classical ext rw by_cases rw split_ifs exacts rw


refine refine rw rw rw ext infer_instance refine rw rw infer_instance


let let pullback pullback apply simp ext constructor ext


refine intro refine simp simp intro apply intro apply intro refine apply


have cases exact exact refine dsimp split exact exact dsimp


CategoryTheory.Limits.image.ext

let let let m m_mono e let have have convert rw calc g


CategoryTheory.IsKernelPair.pullback

refine pullback.lift simp_rw simp ext ext simp simp apply simpa apply simpa simpa


obtain rw rw constructor intro obtain rw


apply apply intro change simp apply simp rw simp rfl


by_cases exact hasColimitsOfShape_of_equivalence let obtain induction isMin subst exact succ obtain have le_top b rw exact infer_instance isSuccLimit subst exact


refine exact intro simp erw rfl intro refine erw simpa


CategoryTheory.Limits.WalkingCospan.ext

apply rintro have dsimp simp have dsimp simp simp_rw exact exact


refine refine have have exact exact exact exact


convert colimit.isoColimitCocone_ι_inv inferInstance apply apply


convert colimit.isoColimitCocone_ι_inv inferInstance exact exact


apply intro obtain obtain refine intro apply apply dsimp rw simpa


apply intro obtain refine apply simp simpa intro apply simpa simpa


apply intro obtain obtain refine intro apply simp apply rw rw


apply intro obtain refine simp apply rw intro apply simpa simpa


cases zero refine rintro exact exact one refine have have rintro exact exact all_goals


induction refl specialize have rw slice_lhs simp dite_eq_ite, split_ifs simp


cases zero have subst simp succ rw simp have simp rw simp congr exact


rw apply apply apply apply intro split all_goals apply apply intro split all_goals


classical refine exact intro split_ifs cases cases obtain simp cases haveI rw apply cases apply apply ext rw dsimp split_ifs cases rw exact apply simp


have funext specialize apply cases congr apply apply


refine symm fconstructor rintro fconstructor exact exact rintro fconstructor exact exact cat_disch cat_disch


CategoryTheory.Functor.isZero

constructor refine naturality intros exact intro ext apply refine naturality intros exact intro ext apply


constructor rintro haveI apply rintro dsimp use simp reduceCtorEq, exact rfl⟩


apply intro dsimp externalProduct] cat_disch


apply symm apply apply_rules exact exact


suffices rw constructor haveI preservesLimitsOfShape_of_equiv apply apply exact apply_rules intro exact


have rintro change rw have ext constructor rw rintro dsimp replace exact exact


constructor intro obtain exact intro obtain exact


constructor intro induction rel obtain exact refl symm obtain exact trans obtain obtain obtain refine rw rintro apply exact exact


rw constructor rintro refine nth_rw simp rintro exact


constructor intro have rwa intro obtain obtain simp obtain rw


rw constructor intro obtain refine rw intro obtain h exact


constructor intro exact fac uniq hm hc.funext rw exact rintro classical refine let suffices have ext obtain exact simp let let suffices refine simpa


by_contra simp_rw apply refine ext exact exact


classical constructor rintro rw show dsimp refine rw erw simp rintro have rw exact refine intro exact intro funext simp intro funext dsimp simp intro have rw exact rintro funext dsimp split_ifs


let have refine intro suffices apply funext apply


let let have exact fac ext obtain have have dsimp rw uniq ext dsimp nth_rw rw


rw constructor rintro refine conv_rhs simp rintro exact


intro refine intro induction refl rw have erw rfl


let have rw apply exact rw infer_instance


refine let exact congr_fun choose exact funext


have obtain exact exact constructor intro refine simp exact intro obtain obtain exact rintro refine obtain obtain exact obtain exact


let apply rw refine dsimp obtain have e.ιColimitType_map have e.ιColimitType_map dsimp rw simp obtain exact


constructor intro exact rintro let have rw grind exact


constructor rintro exact exact rintro apply exact


refine constructor rintro exact rintro apply


obtain exact by_cases obtain exact exact


subst have ext_of_isPullback rw have dsimp intro obtain obtain obtain rfl obtain rw obtain rw obtain rfl


obtain have have rw refine have simp obtain exact exact exact


intro have ext exact apply intro rw exact


intro have ext exact rw apply intro conv_lhs haveI exact


intro refine apply intro simp have rw exact


intro convert hc exact convert ext simp intro rw refine exact


intro convert hc exact simp constructor intro rw refine have exact intro have simp rw refine exact ext simpa


intro have hc ext dsimp exact constructor rintro refine refine exact exact


have have intro have let have have intro apply exact haveI simp_rw infer_instance have intro rw dsimp simp have let let refine ι naturality rw simp_all intro dsimp ext all_goals simp pullback.lift_snd, congr exact rw dsimp rw congr exact let refine exact simp intro rw ext all_goals simp pullback.lift_snd, rw dsimp rw rw dsimp rw have simp have apply rw rw infer_instance have exact ext dsimp simp intro apply dsimp simp rw refine rw congr rw dsimp simp dsimp simp


have have intro refine intro let have have intro rw dsimp simp let let let have rw simp rw have symm convert apply intro rw rfl clear_value apply intro rw dsimp simp congr exact rw have convert refine rw exact clear_value ext simp


constructor introv rw constructor intro exact rintro exacts introv let let have apply rintro rintro clear_value subst change rw constructor rintro exacts intro exact


rw introv constructor rintro let obtain constructor rw haveI have dsimp simp exact rw haveI have dsimp simp exact rintro refine let let have have rw exact


refine refine ext exact dsimp infer_instance)).some


refine ext exact dsimp infer_instance)).some


intro let have apply exact rintro simp have rotate_left simpa congr_app ext dsimp simp intro simp refine simp exact simp obtain have rotate_left ext simpa simpa rintro simp exact simp mapPair_right] exact obtain clear_value subst refine dsimp rintro simp induction simp simp


intro refine intro have rotate_left ext simpa mapPair_left, extendCofan_pt, dsimp ext simpa extendCofan_pt, let have apply exact rintro simp clear_value subst apply intro simp intro simp ext simp intro simp pair_obj_right, refine intro simp induction simp simp induction zero succ have rotate_left ext dsimp rw rfl simpa colimit.ι_desc,


refine ext simp split subst simp refine intro simp split subst rw exact intro simp


classical let have clear_value subst have convert exact


classical let have clear_value subst refine nth_rw convert swap exact simp exact


let have have change infer_instance) have let apply


ext constructor intro exact rintro constructor intro rw apply simp intro obtain exact


obtain obtain obtain simp have obtain simp refine rw rw rw exact


obtain dsimp have obtain simp refine simp simp simp exact


refine rintro obtain obtain obtain obtain obtain dsimp have rw obtain simp rw apply refine dsimp simp dsimp simp dsimp simp rw exact rintro obtain obtain obtain obtain exists_leftFraction let let dsimp simp rw apply refine have obtain simp refine dsimp simp dsimp simp dsimp simp exact obtain exists_leftFraction dsimp simp have rw obtain simp refine simp rw simp exact have obtain simp refine dsimp simp dsimp simp dsimp simp exact


simp constructor intro rw exact intro congr exact


have have have rw infer_instance dsimp rw


let let obtain obtain obtain refine rw g.map_compatibility


constructor intro rw apply intro simp congr exact


constructor intro rw obtain dsimp grind rintro simp


simp constructor intro obtain obtain dsimp have simp obtain have rw obtain simp refine rw rw rw rw exact intro exact


obtain obtain obtain dsimp refine dsimp rw rw


have have obtain let f f s hs have have have rw infer_instance refine rw rw nth_rw rw


obtain have obtain dsimp let f f f s hs have have have rw infer_instance refine rw rw rw nth_rw rw


obtain obtain obtain dsimp rw add'_eq rotate_left rw exact rw exact rw dsimp rw


obtain obtain obtain dsimp rw add'_eq hα, dsimp rw


constructor intro infer_instance intro suffices refine have have this rw add_comp, rw intro obtain have rw


let let let map have rw rw apply have let let calc isoWhiskerRight isoWhiskerLeft have simpa have have refine all_goals exact exact


suffices refine rintro apply rintro apply refine ext cases apply rintro simpa have have simp refine all_goals


funext ext constructor intro apply intro let haveI suffices rcases rcases simpa intro induction nil let rw refine rcases apply apply


have rw let let let let let let associator let have ext rw simp dsimp rw erw rfl, simp rw


let let let have constructor rintro rwa intro have rw infer_instance refine rw exact


let have suffices refine obtain obtain exact intro obtain dsimp rw let refine have zigzag_obj_of_zigzag refine exact apply refine ext dsimp rw


rw have let exact w hw have isConnected_of_equivalent exact


have have have let have have rw intro rw dsimp simp infer_instance rw infer_instance


have have have zigzag_isPreconnected calc comm comm constructor


constructor intro rw apply intro have simpa


have obtain exact exact isEquivalence calc


let let change letI let have ext simp simp


constructor intro have have rw intro have have rw dsimp rw intro exact


have let map have have have let let have exact


obtain obtain have simp have simp have simp rw assoc, replace simp have simp convert exact exact


have have dsimp rw curriedTensorPreIsoPost_hom_app_app, tensorHom_def'_assoc,


letI refine refine dsimp rw curriedTensorPreIsoPost_hom_app_app curriedTensorPreIsoPost_hom_app_app monoidal_simps simp simp map_δ_μ_assoc, simp refine have dsimp monoidal_simps simp tensorHom_def, refine have dsimp monoidal_simps simp


revert apply intro let let let haveI refine intro refine have rintro exact exact intro haveI refine rw rintro intro let haveI refine intro refine rintro exact apply apply rintro


let let let let have isoWhiskerLeft isoWhiskerLeft isoWhiskerRight isoWhiskerRight refine intro exact intro have apply


let whiskeringLeftFunctor eqToIso ext change rw ext dsimp rw eqToHom_refl] dsimp rw rfl) exact


have rw exact let let let exact isEquivalence


let have refine dsimp rw comp_id, map_id, rw


dsimp constructor intro let rw dsimp rw intro let rw dsimp rw


apply apply apply apply apply apply simpa


constructor intros infer_instance intro have have rw apply exact


obtain simp let let let let let let rw change let liftNatIso have γ.hom.app simp simp


have have have have have have have simp congr rw


have apply simp refine simp assoc, nth_rw simp


let suffices obtain obtain exact intro induction nil cons obtain exact simpa


let rw apply convert simp intro convert simp intro convert simp


constructor rintro exact rintro exact inv_rot_of_distTriang


obtain obtain have have have have have have dsimp simp obtain have have dsimp simp refine rw rw cancel_mono hφ₁,


have obtain obtain refine refine dsimp simp


refine clear intro obtain obtain obtain have have dsimp obtain rw rw simp obtain let change have obtain let have refine inv rw dsimp rw rw dsimp simp


constructor intro let obtain exact mem⟩ rintro exact


let let let let have apply apply simpa exact


constructor rintro simp exact simp exact simp exact simp exact


refine symm refine exact dsimp rw dsimp rw apply


letI letI let letI dsimp exact letI dsimp exact letI letI let apply


apply rw dsimp rw adj.homEquiv_naturality_right, apply


dsimp have slice_rhs clear slice_rhs simp


suffices simp simp simp slice_lhs simp slice_lhs simp


tfae_have h have intro have rw rw simp infer_instance intro have simp rw infer_instance tfae_have let have erw exact tfae_have h, rw intro have rw simp have rw refine have ext simp simp rw simp curriedTensor_obj_obj, have rw suffices from rw refine constructor refine ext simp types_comp_apply, have rw simp tfae_have conv conv rw rw rw have have rw ext simp yoneda_obj_obj, rw simp rw simp tfae_finish


dsimp apply rintro simp apply rintro simp apply rintro


ext constructor rintro exact rintro letI exact


apply rw associator_inv_naturality_right_assoc, rightUnitor_inv_naturality_assoc, simp rw simp


rw apply rw associator_inv_naturality_right_assoc, dsimp rw


unfold have mateEquiv_conjugateEquiv_vcomp have conjugateEquiv_mateEquiv_vcomp rw unfold congr apply ext simp prodComparisonNatTrans_app] rw simp


unfold have iterated_mateEquiv_conjugateEquiv rw congr apply ext unfold simp prodComparisonNatTrans_app, rw simp apply simp rw slice_lhs simp unfold simp


let let let let apply intro let apply apply exact have dsimp rw ir.left_triangle_components, apply haveI apply


simp erw rw prodComparisonIso_hom apply rw apply rw apply


dsimp erw homEquiv_symm_apply_eq, apply rw simp rw uncurry_natural_right, uncurry_natural_right,


have congrArg dsimp corepresentableBy₂, simp simp simp


apply dsimp ext simp whiskerLeft_id, rw simp unit_app_map_app_assoc] rw simp rw simp


apply dsimp ext simp whiskerLeft_id, exact


dsimp rw apply dsimp ext dsimp simp simp


apply apply ext dsimp simp tensor_obj, tensorHom_id] simp simp whiskerRight_comp_unit_app_assoc, externalProductBifunctor_obj_obj, rw haveI dsimp simp rw simp


apply apply ext dsimp simp externalProductBifunctor_obj_obj, unit_app_braiding_hom_app_assoc, unit_app_map_app_assoc, simp simp whiskerLeft_comp_unit_app_assoc, externalProductBifunctor_obj_obj, congr rw haveI dsimp simp rw simp


ext dsimp apply intro apply dsimp simp simp


set let apply let letI letI apply infer_instance apply let apply tensorRight exact


set let apply let letI letI apply infer_instance apply let apply exact


apply intro induction id α_hom α_inv l_hom l_inv ρ_hom ρ_inv comp whiskerLeft whiskerRight hg have change rw exact


rcases apply clear induction comp whiskerLeft whiskerRight funext simp


revert induction simp intro dsimp whiskerRightIso_hom, rw simp intro dsimp whiskerRightIso_hom, rw have simp all_goals


intro ext1 exact exact rw rw exact ext rw rw exact


intro ext1 rw rw exact ext rw rw exact exact exact


letI have simp infer_instance have simp infer_instance apply


have conv rhs rw rw whisker_exchange_assoc, simpa


apply rw simp simp simp exact rw simp simp simp exact


slice_lhs slice_lhs slice_lhs slice_lhs slice_lhs slice_lhs simp rw simp rw rw rw slice_lhs rw slice_lhs simp rw simp simp slice_lhs simp rw simp rw simp slice_lhs simp rw simp slice_lhs simp rw simp slice_lhs simp rw simp rw simp simp slice_lhs simp rw simp slice_lhs simp rw simp slice_lhs simp rw simp rw simp slice_lhs simp rw simp simp slice_lhs rw slice_lhs slice_lhs simp rw simp slice_lhs slice_lhs dsimp rw slice_lhs monoidal


classical cases ext simp comp_dite, leftDistributor_hom, simp_rw simp simp simp


classical cases ext simp comp_dite, rightDistributor_hom, simp_rw simp simp


rw calc ε_ congr simp rw repeat iterate simpa simp rw simp


rw calc η_ congr on_goal simp iterate repeat iterate simpa simp rw simp


dsimp constructor rintro exact rintro exact


apply constructor rintro exact rintro exact


constructor rintro exact rintro rw constructor


ext constructor intro rw obtain exact intro exact


intro induction map induction of id comp_of


apply introv have pullback.fst apply apply simp rw apply exact rw iterate rwa


constructor intro refine have exact intro ext simp exact


refine refine exact have exact simp refine exact exact exact exact simp


constructor intro exact intro simp have infer_instance


constructor intro have exact intro exact


constructor intro refine ext rw constructor intro exact rintro simp rintro infer_instance


constructor intro exact intro constructor intro exact


have have pullback.map rw apply exacts baseChange_map


constructor rintro exact rintro constructor intro exact


intro have have have h₁.desc h₁'.hom_ext have dsimp simp rw exact


intro have let let have have have hc₁.hom_ext obtain rw simp rw exact


refine exact set have rw apply exact exact


apply intro have exact intro have exact hf


rw intro obtain let let pasteHorizIsPullback pullback.congrHom left exact


rw suffices intro obtain obtain rfl obtain pullback.snd have g pullback.lift pullback.map exact hg


obtain induction isMin obtain simpa succ rw exact isSuccLimit hj letI bot_le exact


refine small_of_surjective letI rintro exact


ext refine exact π isLimit prop_diag_obj exact ι isColimit prop_diag_obj


ext refine exact ι isColimit prop_diag_obj exact π isLimit prop_diag_obj


ext simp constructor rintro simp obtain exact exact rintro exact exact


refine rintro simp obtain exact simp intro rw exact


ext constructor rintro exact rintro exact


refine have obtain exact let have obtain exact have have obtain have essentiallySmall_of_fully_faithful exact


induction isMin obtain simp succ hb rw exact isSuccLimit hb simp intro exact


have small_of_injective induction isMin obtain simp infer_instance succ have rw infer_instance isSuccLimit simp have have exact infer_instance


have have refine simp obtain exact simp prop_iSup_iff, choose obtain refine rw exact obtain exact refine monotone_transfiniteIterate dsimp rw simp exact monotone_transfiniteIterate


refine rw exact have conv_rhs rw exact refine


ext simp constructor rintro exact rintro exact


obtain let have choose refine exact intro simp obtain exact intro obtain let exact


obtain obtain refine simp constructor exact exact


constructor rintro refine let have have exact suffices have apply intro rw simp congr apply simp rintro haveI refine exact inv


intro generalize induction zero cases nil cons succ obtain exact


fapply rintro rfl rintro rcases dsimp simp


subst_vars fapply rintro rfl rintro dsimp induction nil simp apply cons ih simp have convert rw


fapply intro rw intro induction nil cons erw simp


apply intro ext specialize have simpa intro funext specialize have simpa


CategoryTheory.Biprod.isoElim'

obtain letI rw infer_instance letI exact


by_contra set have have dsimp rw conv_lhs slice rw simp rw conv_lhs congr skip slice rw simp conv_lhs slice rw simp exact


cases intro have set have have dsimp rw simp grind exact


classical apply have by_contra simp exact


haveI change infer_instance have piComparison ext convert haveI haveI rw infer_instance haveI apply


have prodComparison ext haveI haveI rw infer_instance haveI apply


refine exact simp apply simp convert simp infer_instance simp convert simp infer_instance cat_disch


ext simp simp split_ifs cases simp simp convert simpa


ext simp simp conv_lhs simp apply simp intro simp simp convert convert convert convert simp


classical refine intro apply apply cases simp exact rw simp) rw simp)


obtain constructor intro exact intro constructor intro have have exact


letI haveI constructor let dsimp let constructor apply apply let exact


letI haveI constructor intro let dsimp let constructor apply apply let parallelPair.ext exact


dsimp finiteSubcoproductsCocone_ι_app] ext simp rw simp intro rw simp


dsimp finiteSubproductsCone_π_app] ext simp rw simp intro rw simp


classical ext simp biproduct.lift_π, ext simp congr funext simp


have intro ext simp simp have intro ext simp simp exact right_id


refine refine rw dsimp simp isoHomologyι_inv_hom_id,


have refine intro have have obtain use rw exact


classical exact mul_comm obtain obtain simp


obtain rw exact obtain haveI refine intro obtain exact


fconstructor intro rw obtain rw exact rintro have have finrank_pos_iff_exists_ne_zero.mpr lia


refine have suffices have coyoneda.obj intro ext simp exact


constructor intro exact intro infer_instance


refine rw obtain have obtain exact simpa


have rw refine obtain exact obtain exact


choose let let let let let fst snd let right fst snd have have have hasCardinalLT_prod refine rintro rw dsimp obtain obtain obtain rfl have have rw hasCardinalLT_sum_iff hasCardinalLT_sum_iff refine let exact simpa


simp obtain simp obtain exact rfl rw obtain obtain exact


have have have rw refine obtain obtain have let have obtain exact exact rfl have obtain exact rfl rw obtain obtain exact let rintro exact exact rintro obtain obtain rfl rw rintro exact exact exact have let top isTerminal uniq_terminal hj obtain exact rfl exact simpa


have obtain exists_cardinal_directed.aux have exact exact


let let let refine obtain let let have have let exact


rw intro have refine simp infer_instance exact


constructor intro exact intro constructor intro rw have exact


have obtain h₂ exact choose obtain exact


have obtain rw refine choose exact by_cases obtain choose simp obtain let exact rw simp obtain obtain exact simp⟩


have obtain obtain have let let have exact rw obtain have dsimp simpa let let have obtain let let refine simpa exact let property φ dsimp rw refine apply rw ext have have dsimp rw


have let let have have have simp dsimp simp let let have have let refine apply ext simp have have dsimp simp


refine ext simp dsimp ext apply simp exact choose exact


refine refine simpa have simp exact simp obtain dsimp refine ext dsimp ext simp simp refine rw simp


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


rw obtain refine rw rintro refine obtain obtain hi exact


have obtain rw refine rintro have rw infer_instance


refine obtain exact have have exists_generator constructor


refine have obtain obtain ext have dsimp rw simp exact


constructor rintro rcases rcases exact rintro dsimp refine


subst_vars fapply rintro dsimp congr rintro dsimp refine simp congr


CategoryTheory.Quotient.linear

letI exact rintro obtain obtain rw comp_smul rintro obtain obtain rw


CategoryTheory.Regular.instMonoDesc

apply let let let let let pullback.lift let let pullback.lift the have refine refine simpa simp above, it have apply dsimp infer_instance rw convert all_goals


intro have simp apply dsimp rw simp erw dsimp simp


intro have simp simp unit_naturality_assoc] slice_rhs simp erw rw dsimp rw dsimp rw


intro rw apply dsimp simp left_triangle_components_assoc] erw dsimp rw


intro rw simp unit_naturality_assoc, slice_rhs simp rw simp


subst ext dsimp simp dsimp simp dsimp simp erw rfl


dsimp simp congr rw dsimp rw shiftFunctorAdd'_assoc_inv_app shiftFunctorAdd'_assoc_inv_app shiftFunctorAdd'_add_zero_hom_app,


rw shiftFunctorCompIsoId_add'_inv_app dsimp rw


rw shiftFunctorZero_hom_app_shift, dsimp rw


rw cancel_mono simp dsimp simp dsimp simp dsimp simp shiftFunctorAdd'_assoc_hom_app_assoc shiftFunctorAdd'_assoc_hom_app_assoc shiftFunctorAdd'_assoc_hom_app


ext have dsimp simp rw shiftFunctorAdd'_assoc_hom_app simp_rw simp


letI exact commShiftIso_zero ext simp commShiftIso_add ext simp


letI exact commShiftIso_zero ext dsimp simp commShiftIso_add ext dsimp simp rw dsimp rw


subst obtain simp erw change congr rw dsimp congr apply


have dsimp cat_disch rw congr change simp


rw constructor intro replace simpa intro rw rw


constructor intro rw intro rw exact intro rcases rw exact exact


change simp whiskeringRight_obj_map, rfl


intro let s have intro apply apply let have have rw intro apply intro apply intro have trans have rw grind have conv_lhs rw simp refine rintro rw apply intro apply intro apply intro rw


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


apply refine apply intro change rw apply


constructor intro apply intro change rwa intro rw intro apply


intro rw refine rintro simp ext dsimp rw have congr_arg have ext rw simp apply intro rw constructor intro rw apply rw apply intro rw apply rw apply intro rw let have intro apply rintro rw show conv_lhs rw rw apply apply refine intro simp ext1 dsimp rw apply


intro rw have intro trivial suffices rw exact apply intro simp ext1 dsimp rw apply


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


constructor intro simp apply exact intro simp rintro exact


rw intro have rw intro let have let obtain refine convert exact exact


rw suffices change rw exact apply apply use intro rw apply apply obtain exact


constructor intro induction of obtain refine obtain exact top transitive obtain choose exact exact


ext refine induction of apply simp exact top transitive induction of obtain apply apply simp exact rintro change rw apply have generate rintro exact apply apply refine convert aesop top transitive


rw dsimp apply have rw exact exact preservesLimitsOfShape_of_evaluation inferInstanceAs


refine rw let have inferInstanceAs have inferInstanceAs let let exact apply refine ext cases simp refine suffices ext simp rw intro have have exact


constructor intro rw refine constructor apply intro specialize rw exact intro rw exact


constructor intro induction of obtain refine have exact obtain exact top refine have have exact exact transitive obtain choose exact intro apply exact refine rw exact


constructor intro specialize rw obtain exact intro refine obtain rw exact


intro replace rw obtain let let let let let ht.conePointsIsoOfNatIso refine apply intro simp rw erw change erw rfl


constructor rw exact intro refine obtain convert rw simpa


intro have refine simp refine simp exact


intro specialize rw rw intro obtain exact


intro have specialize rw rw intro have have rw simp obtain refine simpa simpa


constructor intro have rw exact intro apply intro rw infer_instance


apply intro obtain let let exact intro have have dsimp let refine all_goals


let let let let let let let let have let refine refine rintro all_goals


dsimp rw constructor rintro exact intro exact


rw intro have obtain have rw intro let have let obtain refine convert exact exact


rintro have rw apply intro refine cases exact apply exact


rw suffices change rw exact apply apply use intro rw apply apply cases exact


constructor intro induction of rcases refine rcases exact top transitive rcases choose exact exact


refine apply refine funext ext refine rintro simp rw infer_instance


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


refine apply refine funext ext refine rintro simp


refine apply refine exact obtain let refine refine simp infer_instance obtain rw convert exact


ext apply intro dsimp simp simp congr cat_disch


ext apply intro dsimp simp simp dsimp simp dsimp simp simp congr dsimp ext dsimp simp simp


ext dsimp simp simp congr dsimp ext rw simp


dsimp rw comp_apply apply apply dsimp rw ext simp rw erw cases


dsimp let rw delta rw apply dsimp apply intro simp rfl


dsimp delta dsimp rw dsimp let rw apply apply intro dsimp rw erw simpa


constructor intro obtain use ext apply_fun convert all_goals dsimp rw erw cases rintro apply use apply intro apply_fun convert all_goals dsimp rw erw cases


obtain obtain simp choose rw let use let homOfLE rintro rw apply exact let homOfLE rintro rw apply exact use ext1 let specialize let apply_fun convert exact exact


intro simp rw obtain apply intro apply_fun exact


have choose exists_rep let choose let use ext dsimp rw apply intro simp use let homOfLE intro apply cases exact use ext let let let let change apply rw erw rw let exact


rw intro apply rw constructor intro apply intro apply_fun apply_fun dsimp convert rintro obtain use apply rw ext dsimp rw rfl


apply rintro dsimp have have dsimp simp simp


apply intro apply intro have dsimp simp rw


let let let let change adj₂.unit.app apply have rw rw apply simp congr exact


rintro unfold rcases rcases suffices apply simpa


constructor intro let over let have have conv_lhs conv_rhs simp apply injection injection exact


constructor introv obtain apply simp simpa


simp choose refine intro refine simp let have intro rw apply simp let obtain refine obtain choose refine rw types_comp_apply, apply simp


induction of obtain suffices intro obtain refine simp top transitive refine rw exact


apply apply intro induction of top transitive apply intro apply


ext rw refine induction of top transitive obtain choose refine exact obtain exact refine rwa


refine intro induction of top transitive intro induction of top pullback transitive


rw constructor intro simpa intro obtain apply intro obtain exact apply intro obtain exact


constructor tauto intro apply rintro exact


have apply let have have simp exact have intro rw exact refine rintro change apply rintro rw rfl intro exact


refine apply rintro rw apply rintro exact


suffices iZW₁ rintro simp generalize generalize obtain obtain exact introv refine simp


have intro rw use constructor exact exact haveI apply


ext apply ext erw symm change apply sheaf_eq_amalgamation exact intro conv_lhs simp homOver_app] congr simp congr have naturality_apply simpa


ext apply ext erw symm change apply sheaf_eq_amalgamation exact intro conv_lhs dsimp


constructor intro apply intro refine refine refine intro simp apply simpa


apply rw intro apply rw intro simp sheafToPresheaf_map, exact


have obtain exact have obtain exact choose choose exact


rw refine rw convert refine rintro obtain obtain exact rintro exact


rw refine replace rw convert refine intro exact rintro replace dsimp rw change simpa


intro obtain obtain obtain obtain obtain obtain dsimp rw mor_precomp apply


ext constructor rintro exact rintro exact


constructor intro rw constructor apply rintro change rw apply


constructor intro infer_instance intro let have have have have have rw infer_instance


rw constructor intro apply intro simpa intro rw simpa


rw simp_rw simp apply intro apply intro rw rw constructor intro funext simpa intro rw simp


rw constructor intro apply rintro simpa intro rw simpa


rw simp_rw apply intro apply intro rw constructor intro funext simpa intro rw simp


rw constructor intro ext simpa intro apply_fun simpa


rw simp rw simp_rw apply intro apply intro rw constructor intro funext simpa intro rw simp


ext have rw conv_rhs apply ext constructor rintro exact rintro exact have rw exact rw constructor rintro exact rintro exact


refine have simp multicospanShape_snd, simp


refine rw rintro refine simp exact rw rintro exact


refine rw rintro refine simp rw rintro simp_rw apply rw convert simp


constructor intro exact intro rw rintro obtain exact


letI letI letI letI refine refine refine simp rw simp refine simp rw simp refine simp simp


ext let refine refine apply apply apply refine have simp have simp exact simp subst refine simp simp apply simp simpa apply simp simpa


ext constructor rintro exact intro exact


refine refine let pullback.map rw simp exact exact


have suffices simp_rw isomorphisms.iff] intro let have simpa have rw simpa have pullback.snd rw cat_disch rw infer_instance


rw apply intro cases exact exact rintro exact exact


choose choose let f i let f i let refine cases have refine rintro have refine rintro rw apply rwa


constructor intro apply haveI apply intro haveI rw


constructor intro simpa intro simp_rw congr


constructor intro apply exact exact intro apply exact exact


change constructor rintro rw simp intro ext convert rw simp


rw apply intro constructor intro exact intro refine intro apply exact


rw rw rw apply constructor intro apply intro simpa intro apply intro simpa


rw constructor intro exact intro use intro apply intro rw hx simp


refine obtain refine rw rw obtain h exact


rw refine obtain exact obtain rw dsimp subst exact


obtain have dsimp let s simp exact invFun s replace simp exact simp convert ext simp


let s replace dsimp have s.property have dsimp rw let replace dsimp simp convert invFun s s.property simp rfl


obtain rw isSheafFor_iff_generate] convert refine rintro refine simpa cat_disch rintro exact


dsimp rw congr dsimp rw refine dsimp simp dsimp rw dsimp rw simp_rw rw congr rw erw rfl


constructor apply refine intro apply intro dsimp simp_rw refine simp congr refine dsimp erw conv_lhs simp rw simp conv_lhs rw rfl


rw dsimp rw dsimp rw sheafifyLift_id_toSheafify_assoc]


apply ext constructor intro exact rintro exact


constructor rintro rw suffices rw intro rw exact intro have let have intro apply have have have have refine erw simp refine apply intro rw exact intro constructor


constructor rintro rw constructor intro constructor


constructor intro exact intro infer_instance


constructor intro let let equalizerSieve refine rintro simpa intro refine rw exact intro exact


constructor intro exact intro rw infer_instance


constructor intro infer_instance intro have rw apply


ext dsimp constructor rintro exact rintro let let let refine rw exact


refine rw obtain refine ext exact rw exact


ext constructor rintro exact intro exact


refine intro obtain simp induction of rw exact top rw simp transitive ih refine obtain rw exact rw intro rw rw exact


ext dsimp delta simp simp_rw congr exact


ext refine dsimp let rw congr refine erw simp let erw congr refine convert all_goals


rw suffices intro refine suffices isIso_ι_of_isInitial intro have have rw infer_instance


refine isColimitOfPreserves constructor rintro exact rintro exact


suffices rintro obtain simp obtain simp simpa intro obtain simp_all


let i.elim convert_to refine exact refine convert refine exact


let let let let let let let convert_to refine exact refine convert refine exact convert refine


refine rw intro induction of top pullback transitive exact


constructor refine rw exact intro suffices induction of top pullback intro rw exact transitive intro simp choose choose refine intro refine refine simp simp rw simpa let have intro rw rw choose let have intro apply intro simp rw dsimp simpa simpa obtain refine refine rw on_goal refine rw on_goal refine rw apply simp


refine induction of use exact top pullback obtain have refine rw apply rwa transitive obtain rw obtain replace obtain rw obtain use choose refine rw intro exact rw apply exact


rw have have rw intro obtain refine apply_fun simp ht₂


ext simp by_cases rw have apply_fun injective_of_mono ext exact


simp constructor intro apply rw infer_instance intro constructor intro rw dsimp rw erw dsimp rw apply


rw apply intro rw sheafComposeNatTrans_fac


suffices rw rfl apply convert dsimp simp


dsimp rw rw intro specialize rw exact rintro let rw erw rw exact


constructor intro have rw specialize rcases simpa rintro let constructor rw intro let apply ext apply


constructor intro refine exact intro refine intro exact intro funext apply intro funext apply intro rw rfl


refine intro let obtain let use dsimp intro apply intro apply rintro apply rw congr apply


rw refine rintro let exact intro refine apply intro symm simp


let parallelPair parallelPair refine parallelPair.ext dsimp simp piComparison_comp_π_assoc] dsimp simp piComparison_comp_π_assoc] refine refine dsimp simp


constructor intro refine apply intro have rw rw replace apply intro rw refine refine letI apply apply simpa


constructor intro rw intro dsimp ext refine have dsimp simp rw rfl


let π naturality rintro dsimp rw have simp let have dsimp erw use intro exact


intro apply refine naturality rintro apply rintro dsimp rw rw congr simp rw intro dsimp have rw exact intro rw apply ext apply rintro dsimp let refine rw


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


intro have simp dsimp have have let let let have have have cat_disch


constructor intro refine exact fac intro replace have cat_disch uniq intro replace apply exact intro replace let use constructor exact exact


refine change rw rfl change change rw simp


funext ext constructor rintro exact rintro exact


funext ext constructor rintro apply rintro exact


funext ext constructor rintro exact rintro apply


ext rintro exact rintro rw obtain rw exact


rw intro constructor rintro exact rintro exact


ext constructor rintro have rw exact rintro have exact


ext constructor intro obtain exact intro exact


intro constructor intro apply refine rw rintro apply exact


ext constructor rintro simpa intro exact


ext simp constructor rintro exact intro exact


refine rw rintro use exact rintro use simp


apply intro rcases exact intro rcases exact


have by_cases subst rw obtain have exact refine refine refine intro ext dsimp rw exact ext let have dsimp simp ext have exact ext dsimp apply ext simp


apply intro suffices rw exact apply intro exact


refine let have choose dsimp let have intro refine apply intro have have rw exact have intro rw exact congr_arg obtain refine refine intro dsimp rw exact


intro convert apply intro have congr_arg convert rw rfl


CategoryTheory.instEpiSheafTypeToImage

refine ext apply rintro change rw have have dsimp convert


apply intro apply apply rw suffices funext exact


refine refine funext ext refine by_contra have simp


obtain ιFunctorObj_extension refine rw rw


haveI haveI haveI haveI intro constructor nth_rw apply exact rw dsimp infer_instance


let let change have have dsimp rw apply simp rw apply


by_cases rw obtain obtain rw rw dsimp rw rw


obtain obtain dsimp obtain rw rw comp_id, rw rw


induction isMin obtain exact succ isSuccLimit


obtain replace dsimp let naturality let have exact l fac_left fac_right


induction isMin obtain refine have have simp rw succ refine have have simp rw congr exact isSuccLimit refine have have simp rw congr ext have exact


let let let let hom objEquiv homEquiv exact


let have rw simpa have rw refine intro exact have rw refine intro simpa let let let let hom objEquiv homEquiv refine rwa


constructor rintro infer_instance intro ext apply rw exact


have simp rw constructor intro rw intro exact


have rw intro rw constructor rw infer_instance rw infer_instance


ext simp constructor rintro exact rintro exact


ext dsimp simp constructor rintro exact rintro exact


rw refine obtain refine rw exact obtain refine simpa


obtain assumption exfalso apply convert rw


revert apply intro apply apply refine simp refine rw rfl dsimp rw apply


fconstructor intro replace simpa rintro ext simp


refine simpa cat_disch ext simp ext simp


classical revert induction empty insert intro rw simp rcases rw exact rw apply exact


classical revert induction empty insert rintro simp simp rcases exact exact


fapply exact eqToHom dsimp simp convert simp


fapply refine eqToHom factorThruImage exact simp


fapply refine refine rintro refine simpa ext dsimp simp dsimp rw


suffices intro obtain have let inv hom_inv_id inv_hom_id exact


refine apply have rw reassoc_of% apply apply rw


rw refine obtain refine rw exact obtain refine simpa hn


constructor obtain apply exact obtain constructor exact


constructor intro exact intro have exact


apply intro obtain obtain obtain obtain obtain exact


suffices intro have have rw intro let have have obtain dsimp replace simp rw have apply


obtain apply have have have dsimp simp constructor intro obtain have have apply intros constructor


have adj.op ext dsimp simp rw exact inferInstanceAs


dsimp simp commShiftIso_hom_naturality_assoc, congr rw dsimp rw


rw constructor intro exact rintro refine exact


rw obtain dsimp replace dsimp simp refine apply rw unop_comp_assoc, simp


ext refine exact suffices simpa intro obtain simp obtain exact


ext refine exact rw obtain refine suffices simpa intro obtain simp obtain exact


rw refine rw obtain exact obtain have obtain refine rw


obtain let refine isomorphic_distinguished exact


constructor intro rw intro obtain rw intro rw


have dsimp rw constructor intro simp intro rw


rw constructor intro have obtain exact intro rw constructor


revert let change have have isomorphic_distinguished have isomorphic_distinguished have isomorphic_distinguished obtain induction zero succ induction zero succ


have rw intro obtain rw obtain obtain refine have dsimp rw erw refine intro simpa intro obtain obtain rw comp_distTriang_mor_zero₂₃ obtain obtain refine dsimp rw


have have exact fst snd inl inr inl_fst simp comp_distTriang_mor_zero₁₂_assoc inl_snd inr_fst simp inr_snd isBilimit


have have obtain let refine ext simpa simpa


and let obtain let change let completeDistinguishedTriangleMorphism let have have have have suffices have apply all_goals exact refine isIso_of_yoneda_map_bijective suffices intro simpa rw intro have rw obtain have have rw simpa have let have have rw intro obtain have rw productTriangle.zero₃₁] intro exact have exact have simp erw rw rw let have have have rw exact


let have have have have apply all_goals exact


have exact have dsimp conv_rhs have dsimp conv_lhs


have exists_iso_of_arrow_iso have dsimp simp simp let have have have have dsimp refine convert simp


rw constructor rintro exact rintro exact


ext constructor rintro refine exact rintro exact


constructor rintro obtain exact intro exact


obtain let let have refine refine all_goals exact


let suffices intro obtain obtain apply have simp rfl have rw rw exact have intro rw exact intro induction zero succ


let let let isoTriangleOfIso₁₂ have have have have have have have have have have dsimp rw rw refine rw eq₁₃, dsimp rw rw rel₁₃] rw eq₂₃] dsimp rw rw rel₂₃, refine refine dsimp rw


constructor rintro refine rw apply change rw exact


intro induction zero succ ext have exact


set map_zero map_add refine refine rw exact


rw apply threeAPFree_sphere rw rintro have have rw exact


cases dsimp cases simp apply simp rintro exact apply simp exact


obtain refine obtain simp obtain simp refine exact exact simp sub_add, apply rwa rw norm_num exact


calc gcongr field_simp simp norm_num1 exact simp apply nlinarith gcongr exact


have have calc rw sub_add_add_cancel, exact


apply have rw exact rwa mul_div_assoc', exact exact


rw apply have rw exact apply rw exact norm_num1


have rw sub_nonneg, have apply rw apply rw exact apply rw apply apply exact exact exact exact exact


have apply suffices suffices rw apply rw rw apply rw exact apply


Behrend.bound

apply rw grw rw norm_num norm_num1 rw refine rw exact apply have rw exact refine rw exact norm_num1 rw exact refine rw exact positivity


let have have have have have calc rw cast_sub div_eq_mul_inv] gcongr rw have rw norm_num rw gcongr rw neg_le_neg_iff, gcongr apply refine rw exact refine rw exact


refine hs rintro rw obtain rfl all_goals exact exact exact exact obtain exact exact


refine rintro exact rintro simp_rw exact


refine obtain rw have have rw rw refine rw exact


refine obtain rw obtain rw rw exact obtain have convert rw


classical obtain obtain have choose refine calc calc gcongr simp_rw simp_rw rw simp_rw


set clear_value simp obtain refine wellFoundedOn_devosMulRel.induction min clear rintro simp obtain simpa ih obtain simp obtain obtain have refine forall_mem_zpowers.2 rw exact simp rwa refine rw simp replace card_lt_card hsg replace replace card_mono mulETransformRight.fst_mul_snd_subset obtain rw right grw exact obtain exact exact


rintro rw have have simp rwa positivity have rw refine classical have rw convert


rintro rw have rw simp rintro have simp lia rw have have hA.of_image refine simp exact rw refine calc rw have exact


rintro classical let have calc norm_cast rw exact obtain simpa have hA rw add_comm] exact


rintro rw have rw simp rintro have simp lia rw have have hA.of_image hAn.trans rw refine calc rw exact


CovBySMul.trans

classical have obtain obtain refine calc calc


classical refine rintro refine push_cast exact


simp let have rintro simp_rw obtain rw rw congr simp refine rintro simpa


haveI classical set let have have simp have char_dvd_card_solutions_of_add_lt obtain refine simp rw refine rw exact rw simpa x.2.1 rw exact simpa


classical induction zero exact one prime haveI obtain obtain exact composite suffices obtain obtain refine rw rwa exact exact exact rintro induction zero succ obtain ih have calc rw le_card_sdiff obtain have rintro obtain simpa lia refine simp exact simp exact


obtain simp have convert simp simp_rw rw simp


rw refine card_mul_le_card_mul card_le_one_iff.2 obtain refine rw exact exact exact


induction empty insert set set have rw have rw refine rw gcongr exact have calc gcongr rw refine rw card_singleton_mul, exact rw card_singleton_mul


rintro obtain simp have have exact mod_cast


obtain simp have obtain rw refine push_cast rw refine refine le_trans rw mul_comm exact


obtain simp induction zero succ refine calc


have obtain rw obtain refine calc gcongr


haveI set obtain simp obtain refine calc by_cases exact by_cases refine rw exact simp_rw obtain exact


induction base succ obtain simp have have obtain simp have let let let refine calc simp simp gcongr exact exact


obtain simp have refine calc gcongr calc


obtain simp refine calc simpa gcongr exact calc


have have obtain simp have one_le_of_le_mul_right₀ rw refine simp succ_one_eq_two, simp have have gcongr exact simp obtain simp nlinarith nlinarith nlinarith nlinarith nlinarith nlinarith nlinarith simp nlinarith


induction h0 step have grw add_right_comm, exact


have have have have rw smul_eq_mul] let have ext rw refine simpa norm_cast rwa refine rw rw norm_cast rw


intro simp rintro have simp obtain refine rw


have have convert norm_num simp have rw simp intro exact have rw refine simp rw nlinarith


intro simp obtain let let have rw have rw simp refine simp have rw subset_smul_finset_iff] simp refine simp have rw exact have have have refine rw exact have rw linarith simp rw exact


refine rw calc a simp_rw rw invMulSubgroup_eq_inv_mul] rw calc a⁻¹ rw simp_rw rw invMulSubgroup_eq_mul_inv


let refine simp rwa rw exact_mod_cast simpa smul_inv_mul_eq_inv_mul_opSMul


classical have have have have have have positivity obtain exact let let have have cases have simp obtain have have have simpa refine suffices calc have simp let have simp calc simp set have calc norm_cast exact simp_rw gcongr exact simp_all simp ring have replace calc ring calc have have rw gcongr linarith field gcongr simp rintro rw rintro have simpa le_card_mul_inv_eq rw simp have have have exact have mod_cast linarith simpa


have have have mod_cast have simp_rw nlinarith


replace replace replace replace replace exact


by_contra let let have have linarith let have rw calc κ let have rw refine apply exact apply apply exact mem_Icc.2 have let have simp obtain have have exact


obtain obtain have have apply simpa let one_mem mul_mem hb rw apply rw have simpa hb inv_mem ha rw apply rw have simpa self_mem_smul_carrier refine simpa simpa


let have let let obtain obtain obtain have calc ex refine rw calc ε field cardZ calc simp gcongr rw suffices simp rw calc grw gcongr linarith simp


classical let have simp have by_cases exact have have refine exact


obtain simp classical rw singleton_le_singleton]


refine set by_contra have have exact lt_irrefl have refine simpa


simp refine let have have let have refine by_contra have exact rintro refine by_contra exact


generalize_proofs set obtain exact replace simp obtain obtain have refine change rw obtain assumption by_contra exact obtain have rintro rw exact rw rw exact tsub_le_tsub_right refine change rw obtain assumption by_contra exact


Finset.Colex.IsInitSeg.total

classical simp_rw by_contra have rw obtain exact simp exact exact


have refine ext rw refine rw exact rintro obtain rwa exact


classical let suffices obtain exact intro by_cases simp_rw by_cases obtain obtain rw exact suffices rw replace rwa add_le_add_iff_right] have refine simp_rw obtain exact by_cases rw rw rw rw exact exact hs₂.trans


by_cases exact haveI cases rw have exact


classical by_contra obtain have calc obtain refine simpa rw obtain exact let exact


classical obtain let have rw simp_rw have rw on_goal rw refine simp_rw change rw all_goals have rwa rw exact step3.symm


cases cases obtain have let have have have have have have suffices refine refine rw


obtain cases rw simp_rw have exact ne_of_mem_of_not_mem


cases obtain let invFun right_inv rfl classical have apply convert have intro rw refine rw simp_rw simp_rw rw


by_contra simp_rw rw let let have ext fin_cases replace rw contradiction


induction h induction h induction h induction h rw exact


ext constructor rw rintro rw apply_fun rcases rwa exfalso rw exact intro use constructor intro apply_fun simp rcases simp simp by_cases rw apply have have rw intro exact rw


have rw exact calc derangements simp_rw rfl


let suffices simp_rw rw apply rw exact intro rw push_cast rw refine intro have rw push_cast field


have intro simp add_tsub_cancel_right, have simp simp card_sigma,


unfold rw simp rw simp rw apply rw suffices by_cases rw rw simp exact nth_rewrite nth_rewrite exact rw apply intro rw simp simp apply rw simp


rw rw exact rw apply rw apply simp forall_apply_eq_imp_iff₂] exact apply exact


unfold rw split_ifs simp by_cases simp rw simp


convert simp simp split_ifs rw rw rw simp simp


have have have have have mod_cast have mod_cast simp push_cast rw rw field


suffices have exact induction zero ind simp_rw trans congr ext1 have have rw norm_cast trans refine rw rw rw norm_cast


induction hz hi rw apply rintro rw simp_rw aesop


by_contra set have by_contra revert simp let have have have simp_all


constructor intro rcases rw dsimp rw simp intro apply refine rw exact exact rw exact


classical wlog exact by_contra obtain have apply calc


constructor rw intro exact intro rw exact


refine rcases rcases have induction congr ext1 exact


constructor rintro exact intro ext1 have have conv_rhs simp rw


constructor rintro exact contrapose intro apply calc n obtain rw obtain rw exact


constructor intro rw exact intro ext1 have have rw simpa


contrapose constructor rintro exact rintro rw have intro by_contra apply calc simpa


induction nil cons intro simp rw simp rw


induction zero succ have rw simp have rw simp


constructor intro rcases rw refine dsimp rw rfl rintro convert have exact


let change have suffices intro have simpa have have have d.boundaries.orderEmbOfFin c.boundaries.orderEmbOfFin rfl have rw


have have rcases tauto rename_i cases tauto nth_rw rw rfl


split_ifs have rw simp_rw have constructor rw count_take_firstReturn_add_one intro rw simpa rw exact


have rw simp_rw constructor rw intro simp_rw take_append, have simp lia simp_rw exact


induction refl tail rename_i rcases rw rwa have grind


by_cases simp rw simp_rw have have rw exact termination_by


letI let eq_zero_of_not_le suffices suffices rw apply_fun symm simpa clear ext simp calc exact


letI symm calc congr rw rw rw rw simp apply simp exact simp exact


by_cases have simp obtain apply obtain have exact


classical by_cases simp symm apply simp intro rw simp contrapose simp rcases simp exact rw calc simp congr simp simp have rw simp rcases exact


classical rw calc rw simp congr split_ifs obtain simp simp zero_smul, congr aesop obtain simp congr obtain


unfold intro rw obtain rw intro obtain grind exact


have suffices convert rw apply suffices grind


refine intro grw refine nontriviality rw norm_cast grind


by_cases specialize contrapose have rw rw congrm suffices contrapose simp rw apply suffices contrapose simp suffices contrapose exact


suffices obtain apply contrapose rw have refine contrapose exact exact refine simpa suffices exact obtain refine suffices apply exact ext simpa


simp_rw apply grind intro rw have have simp intro rw have rw suffices f simpa rw rw simp intro suffices rw grind


rw refine have rw have intro suffices intro refine rw refine intro exact exact exact


nontriviality rw simp_rw conv ext rw refine intro rw exact suffices intro obtain refine rw intro have simp


nontriviality let have rw rw apply rw rw exact


obtain simp simp refine calc rw sum_Ioo_add_eq_sum_Ioc] simp lia congr simp rw rw simp lia


classical refine rintro refine rw decide


let have haveI open calc rw simp_rw ring_nf


trans simp_rw refine trans simp_rw exact refine simpa rw refine simp exact rw refine simp mul_le_mul_iff_right₀, refine gcongr simp lia lia refine filter_upwards have simpa


refine rintro obtain obtain assumption exact assumption


classical rintro ext simp cases inl obtain cases inr cases inl obtain simpa inr obtain simp by_contra simpa


rintro ext obtain simp refine cases cases


classical obtain specialize obtain set refine rw exact exact intro rw clear rw congr rw apply intro rw rw apply intro rw obtain simp


cases obtain refine obtain refine convert simp


obtain refine obtain refine obtain use simpa


hallMatchingsOn.nonempty

classical refine apply intro convert simp rw


hallMatchingsOn.finite

classical rw let rintro refine rw exact apply intro ext rw simpa


let have intro rw apply ext simp have simp apply


haveI let have intro ext simp have simp_rw apply


haveI specialize rw by_cases have convert ext simp rw by_cases rw exact rw exact subst simp


haveI haveI let have rw calc choose let let have calc rcases refine rintro have intro simpa by_cases intro simp split_ifs rwa specialize rw exact


haveI have simp intro exact have simp rw refine rw gcongr intro simp rintro exact use apply apply


haveI rw have apply calc let rcases set let have simp_rw rwa rcases have intro have rw exact have refine refine intro simp split_ifs exact exact


cases generalize induction ind rcases rw exact have intro exact by_cases refine rcases exact


constructor exact rintro rw apply intro rw rintro exact


Hindman.FP.mul

induction head tail obtain use intro exact cons obtain use intro rw exact


let have rcases refine convert exact apply intro filter_upwards rw exact intro exact exact intro apply exact intro rw intro rw filter_upwards obtain filter_upwards apply simpa


let have let let inter_mem p.val.inter_subset_right use suffices intro exact clear intro induction head rintro rw exact tail rintro refine rw cons rintro have simpa rw


refine rw apply rcases have rw convert lia


refine induction rw rcases rw exact apply rw refine have obtain rw apply


obtain rw exact obtain have exact have rw inter_singleton_eq_empty.mpr rw gcongr termination_by


obtain have rw obtain rw exact rw obtain obtain simp_rw exact


obtain obtain by_cases exact obtain exact


refine hI.isBasis_of_forall_insert rw simpa


set have refine rw exact rw refine rintro simp exact


wlog exact simp minimal_iff_forall_diff_singleton


obtain simp suffices simpa mem_ground_of_mem_closure refine exact


obtain exact suffices refine rw exact exact have have rw refine exact


simp_rw apply gcongr simp refine rwa gcongr refine rw simp exact


obtain obtain exact hI.indep.fundCircuit_isCircuit


obtain exact suffices rw obtain refine rwa have simpa rw refine mem_of_mem_of_subset rw exact


have obtain refine refine union_subset subset_diff.2 rw rintro obtain simp simpa rwa rintro exact rintro exact simp exact


choose simp have obtain refine simpa simpa simpa simp exact simp refine simpa simpa


Matroid.IsCircuit.elimination

have obtain by_cases by_cases obtain exact exact exact


suffices obtain obtain exact refine obtain exact insert_subset


have rw refine minimal_iff_minimal_of_imp_of_forall rw exact


rw closure_spanning_iff have refine rw refine rw suffices refine hsp.spanning.superset rw apply exact


intro have simp_rw have apply rw nth_rw refine rw closure_union_congr_right rw exact rw exact


obtain refine rw singleton_subset_iff, exact


suffices aux clear intro obtain simp have obtain rw contradiction obtain rw contradiction obtain rw rw have refine simp rw union_singleton simp


set have have refine exact rw rintro rw obtain exact exact


rw have have refine rw have refine refine rw exact rw obtain he'.subset_isBasis_of_subset have rw exact obtain obtain hI.eq_of_isBasis refine obtain refine specialize rw exact exact


convert hI.inter_isBasis_biInter simp exact


apply simp rintro exacts intro obtain exacts


refine rwa obtain obtain exact exfalso obtain have rw exact refine rw exact


rw have have rw obtain rw rw he.1.mem_closure_iff] rw and_iff_left intro rw subst


obtain obtain ext rw hI'.indep.mem_closure_iff', by_cases simp tauto


suffices obtain rw image_preimage_inter, refine simp hI.mem_closure_iff'] constructor rintro refine obtain rw rwa rintro refine replace have rwa


obtain rintro have rw simp_rw use rintro obtain rwa obtain refine have refine exact


refine have rw singleton_subset_iff, suffices rw simp have rwa


refine have rintro obtain exact have refine simpa simp rw exact


rw eq_empty_iff_forall_notMem] refine obtain rw exact


nth_rw rw diff_eq_empty.mpr rintro rw exact


refine rw obtain rw rw exact obtain refine rw rw exact


suffices rw contrapose exact refine obtain simpa exact


refine obtain refine simp obtain have replace simp not_and, exact refine simp have simp_rw exact suffices simpa exact


simp constructor rintro exact rintro rw exact


rw refine obtain refine rw exact rintro rw refine obtain rw rw


simp constructor rintro exact rintro refine rw subst


Matroid.IsBasis.map

refine rintro have rw simp intro rw obtain exact


refine obtain rw obtain have refine have rw exact


refine obtain obtain rw exact rintro exact


Matroid.instFinitaryMap

refine simp have intro obtain exact obtain refine specialize rwa


rw refine rintro simp obtain obtain exact


refine rw hIX.eq_of_subset_indep diff_self_inter] exact refine


obtain rw hI.indep.insert_dep_iff, by_cases simp simp


wlog rw diff_eq_empty.2 obtain rw diff_union_diff_cancel


suffices simpa diff_union_of_subset exact


wlog obtain rw obtain exact obtain obtain refine have rw refine rw exact


refine obtain have simpa rw have tauto_set


rw isBasis'_iff_isBasis_inter_ground] intro rw exact


nth_rw nth_rw simp refine rw exact obtain show obtain refine rw rw exact


obtain obtain obtain rw hIi.cardinalMk_eq_cRk, exact


suffices from intro by_cases rw exact rw have have contrapose exact choose let suffices refine simp exact rw have by_contra have have refine exact


refine obtain obtain obtain have rwa mk_image_eq_of_injOn_lift hf.image_inter


obtain obtain obtain rw hIY.encard_eq_eRk, exact


simp and_congr_right_iff] refine refine specialize simp true_implies] rw exact intro obtain rwa rw apply exact exact refine simpa exact


Matroid.Finitary.sigma

refine simp intro apply intro convert rw


induction h suffices have rw rwa apply intro classical convert conv_lhs intro simp apply intro simp convert simp h_empty suffices specialize rw rw ext suffices ext set suffices have apply intro rw apply simp apply rw intro simp rw convert ext simp set rw rw by_contra apply rw rw convert exact ext simp suffices apply intro apply simp intro set rw rw convert rw intro specialize rw simpa


classical have rw simp obtain haveI refine suffices rw apply rw convert rw ext by_cases rw rw simp


letI obtain degLex.div f use suffices rw exact apply intro rw intro rw intro apply intro rw split_ifs rw exact exact intro rw rw intro rw convert rw apply simp


rw rw apply intro have rcases rw exact rw exact apply obtain change convert


intro obtain specialize rw have have apply intro exact obtain have simp use exact rw exact have convert simp have have rw exact


constructor intro obtain have stronglyConnectedComponent_eq_of_path obtain contradiction intro by_contra obtain exact


intro obtain obtain let have simpa exact


dsimp rintro induction nil rintro rcases intro rfl intro simp exfalso obtain rw exact cons rename_i rintro rcases intro simp exfalso obtain rw exact rename_i intro simp obtain rw have have have have simp cases have exact cases rfl


dsimp rintro induction nil use simp cons obtain simp obtain obtain simp obtain simp subst use simp


refine induction nil rcases exact cases cons rcases cases simp obtain obtain rw exact


induction nil cases rw obtain obtain exact rw obtain exact


induction zero obtain exact succ have obtain by_cases have obtain refine simp refine simp


induction nil obtain exact rw rcases obtain exact exact


induction nil have subst exact simp cons ih have have v rintro exact have v v intro obtain let have exact cases inl by_cases exact exact inr


Prefunctor.ext

obtain obtain obtain ext apply congr funext simpa


fapply rintro simp apply exact rintro simp apply iterate simp


dsimp fapply intro simp rw rintro subst_vars simp rfl


subst_vars fapply rintro rfl rintro cases rfl exact


rcases simpa apply rw gcongr rw suffices rw exact


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


rw constructor refine rcases exact exact rintro exact


refine simp intro wlog obtain exact let have use rw exact


rcases simp refine simp apply rw gcongr simp and_imp] use intro rcases simp rwa rw intro simp have simp rintro have simp exact rw apply rw have rwa intro simp


set suffices rw simp intro rw have have have have have push_cast dsimp rw have push_cast rw have have simp


rw have intro rw simp_rw rw add_comm have rw exact simp convert rw


by_cases rw exact rw rw rw truncatedSup_infs_of_notMem


by_cases rw exact rw rw rw truncatedInf_sups_of_notMem


set clear_value induction ind replace obtain refine simpa cases cases obtain have rw supSum_singleton exact exact simpa exact exact exact


ext simp constructor rintro exact exact rintro by_cases exact exact


set have clear_value induction empty simp_rw rw obtain insert refine simp exact simp exact


rw card_union_of_disjoint] conv_rhs exact intro rw exact


rintro have dsimp rw rwa sdiff_sup_cancel


intro rw rw split_ifs rw split_ifs exact exact exact


unfold convert ext rw refine simp_rw obtain exact


rw obtain cases unfold split_ifs rw exact cases


rw obtain cases unfold split_ifs rwa cases


rw obtain exact have suffices refine rw exact have rw apply rw exact rwa


rw obtain exact unfold split_ifs rw rwa rwa


set suffices rintro rw by_cases swap obtain exact refine rw split_ifs swap exact rw obtain have have have by_cases obtain refine rw have rwa erase_union_of_mem refine mem_shadow_iff.2 rw exact simp intro have obtain have have have have have have have have intro obtain apply m have refine sup_sdiff_mem_of_mem_compression rw exact convert rw erase_eq_of_notMem have rwa simp_rw refine exact rwa rintro have by_cases obtain apply have have refine rw exact convert rw sdiff_erase rw apply have sup_sdiff_mem_of_mem_compression convert rw insert_sdiff_of_notMem


calc rw exact exact congr simp refine rintro exact rw rw exact rw union_sdiff_of_subset


induction empty simp obtain insert ih specialize ih have have simpa


classical set have set set have simpa subset_latticeClosure have simpa subset_latticeClosure clear_value obtain have four_functions_theorem_aux simpa rintro classical obtain obtain simp_rw exact simpa mul_nonneg simpa mul_nonneg


holley

classical obtain simp simp obtain simp simp have four_functions_theorem univ simpa simp_rw rw exact


rw have rwa card_sdiff_of_subset grw grw


classical refine suffices rw rw image_eq_preimage_of_inverse refine simp_rw by_contra refine rw refine rintro have rw rw exact


have rw revert refine rintro by_cases exact obtain refine rw exact


have obtain rw refine biUnion_subset.2 rw induction empty cons ih set have rintro simp_rw exact have refine rw exact refine nth_rw rw refine rw refine rw refine rw exact rw exact rw add_tsub_cancel_left, gcongr refine rw add_tsub_assoc_of_le card_cons,


ext simp constructor rintro constructor rw simpa erase_le_erase_min simp_rw simp rintro refine rw exact set min have have have rw refine obtain refine simpa refine rcases apply rw refine apply rw apply rw by_contra apply rwa


Finset.Colex.IsInitSeg.shadow

cases obtain have have simp simp obtain simp obtain rw exact


obtain refine obtain rw have have rw exact refine rw rwa rwa exact le_max


refine rintro by_contra have have have have have have obtain rw cases exact assumption refine rw exact


rw have have have contrapose rw rwa rw conv_rhs rw refine simp_rw rw exact


classical set obtain refine rw by_contra exact husable mem_filter.2 obtain rw have rintro by_contra exact have obtain have obtain exact termination_by


obtain obtain suffices have obtain exact exact


set set have calc k.choose congr ext rw constructor rintro have exists_subsuperset_card_eq rwa obtain rw refine rw rintro rw refine rw refine rwa simp_rw rintro refine rw have rwa apply simp_rw rintro simpa


rcases convert rw refine rw exact refine le_of_not_gt have disjoint_right.2 simp obtain exact have have have rwa have have kruskal_katona_lovasz_form have rw have calc n.choose convert apply convert rw rw refine convert lia


let refine rw refine simp_rw exact refine rw refine rw have rw rintro rw exact have exists_eq_insert_iff.2 rcases exact


obtain rw exact replace rw rcases exact rw apply convert simpa simp exact exact exact


ext simp_rw constructor rintro exact refine rw rfl rintro by_cases exact obtain refine rw


rw constructor rintro exact rintro refine rwa


refine mem_upShadow_iff_exists_sdiff.trans rw exact


induction zero succ ih simp erase_sdiff_comm, constructor rintro exact rintro rw exact


rw constructor rintro exact rintro exact


induction zero refine rintro rwa succ simp refine clear constructor rintro obtain refine rw rfl rintro obtain refine rw rfl


refine simp rfl intro set have refine simp exact rw refine rw swap simp rintro exact exact refine simp rintro obtain rw refine obtain rw rw exact refine simp rw by_cases obtain rw refine rw obtain rw refine rwa


intro obtain rw obtain exact by_cases obtain rw obtain refine rw rintro rw exact rw cases rw exact refine rw


induction nil obtain obtain obtain simpa


simp_rw constructor intro apply intro cases rintro exact apply rw apply


obtain obtain rw induction nil cases rfl cons rw specialize rw replace simp rcases cases nil cons rw simp rcases cases rfl simp exact rw exact


intro simp cases nil cons simp specialize rw simp


classical rw constructor rintro refine intro let use simp intro specialize exact rintro refine intro obtain exact rintro simp


classical refine induction nil have refine rcases simp by_contra apply simp support_cons, have tail.isPath_def.mp refine by_contra refine rw have simp


have inhabit classical have rw rw choose refine exact simp intro wlog exact rw obtain exact have have rw lia simp exact simp intro wlog rw exact refine rintro rw length_cons, simp rw simp contra suffices rw simp refine simp


refine have have congrArg congrArg simp simp


refine have have have rw intro let have simpa exact


obtain replace ext refine contrapose obtain let have have obtain suffices refine have simp grind rw push_neg refine simpa have grind suffices suffices rw exact simp_rw grind


refine by_contra obtain obtain have apply refine rw grind have have apply simp simp cases simp suffices apply apply simpa


have refine rw exact rw replace rw exact replace rw exact rw


have classical refine simp_rw refine by_contra rw add_lt_add_iff_right] exact


by_cases have have have gcongr exact rw lia have lia


obtain refine via intro obtain obtain rw classical use is intro rw obtain by_contra subst_vars refine rw have simp have rw lia


obtain obtain rw by_cases rw exact have rw exact