RingFilterBasis.isTopologicalRing

let letI have have haveI apply rw suffices intro rcases refine intro exact intro rw intro simpa intro rw intro simpa


apply rw intro rcases apply rintro exact intro rw intro exact intro rw intro rcases exact


refine replace map_eq_of_inverse rw simpa


rcases have simp have intro rcases refine rintro exact obtain exact


refine exact rintro exact rintro use rw exact union_subset intro have rw rcases rw exact


obtain refine obtain refine refine rwa exact


obtain refine intro exact refine obtain rw exact exact


have obtain contrapose exact refine refine rcases refine simp


replace obtain let let let let replace have ext constructor rintro exact rintro exact replace rw rwa replace simp_rw exact replace hS4.symm have let have have have exact exact hS2⟩


obtain let let let have have have have intro induction zero succ apply rw refine rw exact


point simp_rw intro have ext simp rw apply simpa


let invFun left_inv right_inv have subset_antisymm rw have exact


refine rintro by_contra have rw simp exact rw exact


IsTopologicalGroup.regularSpace

refine have rcases rw refine calc closure


obtain obtain refine rintro refine rw exact


refine simp_rw push_neg obtain have exact


obtain rw have have simpa suffices refine simp exact


by_cases by_cases exact rw contrapose simp obtain obtain use simp simpa


constructor intro constructor exact by_cases exact by_cases simp exact rintro use have simp_rw exact


HasProd.update'

have intro split_ifs simpa simp have simp_rw exact


classical have rw by_cases have lift simp_rw refine simp have simp_rw show true_and, simp


rw obtain rw have simp rw refine filter_upwards have lift convert rw two_zsmul, simp omega


HasProd.sigma

classical refine rintro rcases use intro simp have simp refine change exact refine exact


classical apply simp intro rcases obtain have exact have simp refine change exact have obtain refine simpa


simp haveI rw by_cases rw simp infer_instance rwa


apply have have filter_upwards congr simp grind


Multipliable.hasProd

classical rw split_ifs convert simp simp rw exact simp grind exact exact exact


have finite_const_le_of_tsum_ne_top refine calc


constructor intro refine exacts rintro exact


by_cases exact have lift lift lift lift simp exact


refine replace let refine specialize rw max_lt_iff] rw refine exact


classical simp rw constructor intro obtain use intro specialize simpa rintro rcases rcases use rintro have rw simp exact


simp_rw refine obtain obtain refine by_cases classical refine rw apply simp_rw rintro exact exact obtain exact


classical exact multipliable_iff_vanishing.2 let have calc refine intro simp exact eq


classical by_cases intro obtain rw exact refine rwa


refine by_contra have have exact rintro exact


rcases letI rw simp simp rcases simp apply simpa


classical refine filter_upwards calc conv_lhs rw rw exact


classical constructor rintro exact rintro apply constructor apply simp_rw exact exact


by_cases by_cases exact simp constructor exacts have rw refine rintro simp simpa


MulAction.automorphize

refine intro simp rw convert simp congr ext congr simp


ext apply intro simp set have intro apply use change simp_rw exact


by_cases have ext1 rw have simpa refine rwa


refine obtain refine split_ifs exact exact obtain exact


change have refine refine simp cases exact exact rw simp not_false_eq_true,


have have constructor rw rintro rw rintro exact


apply refine let let have intro simp rcases refine simp refine simp exact calc rw congr refine intro suffices rintro simp intro simp suffices lia


have have have rwa have rwa multipliable_nat_add_iff have simp mul_assoc, simp


that apply intro rcases finite. use intro apply apply intro simpa


suffices simpa rw intro obtain obtain refine rintro apply wlog simpa obtain clear induction zero succ


rcases simp obtain obtain convert unfold conv rw rw refine apply convert refine congr grind


simp refine obtain have exact filter_upwards


SummationFilter.instHasSupportMap

constructor by_cases simp filter_upwards have simp


classical simp congr simp constructor refine simpa exact


classical haveI have rw have have cases mk simp congr refine contrapose obtain simpa


apply apply apply hasDerivAt_of_tendstoLocallyUniformlyOn obtain apply exact filter_upwards


induction zero succ simp_rw rw exact derivWithin_congr intro by_cases simp exact exact


obtain have rw exact hg.congr_inseparable_right tendsto_nhds_unique_inseparable


refine refine rw simp intro have have simp and_self, have simpa obtain obtain exact rw refine rintro have rw refine have trans rw simp rw exact


have obtain nhds_inter_eq_singleton_of_mem_discrete have apply intro contrapose simp rintro have exact


let let have have rw exact have have rw simp_rw exact


let let have have have have rwa rw exact rcases have rcases rw rcases rcases exists intro exact rcases obtain obtain have change exact rcases rcases exists rintro have simp rw have have have have exact


refine rintro constructor apply apply intro rcases exists simp_all suffices map rwa intro have rcases rw rcases rw rcases rw exists rw have grind


QuotientGroup.completeSpace'

the sequential this countably letI letI haveI obtain obtain rw refine of have have simpa rw simp intro rcases refine obtain hM refine rw set have φ choose_spec successive term set have is have have simpa rw simp exact the since rcases refine convert exact


let let let let have have rw uniformity_eq_comap_inv_mul_nhds_one,


constructor simp tendsto_map'_iff, exact


simp eventually_comap, conv have hf filter_upwards simpa


refine rcases set set have have have have set have have calc uR have calc uR set have refine exact simp_rw simp_rw simp_rw have refine exact simp_rw simp_rw simp_rw have have exact


rcases refine exact intro have apply exact rw exact


ball have replace let let exact choose have let refine simp_rw refine exact simp choose obtain hs.elim_nhdsWithin_subcover use intro let by_cases on refine mul_le_mul_of_nonneg_right exact the using calc edist exact simp_rw gcongr


ContinuousAlternatingMap.completeSpace

wlog rw exact intro use ext simp have rw apply


rcases refine rw have tendsto_const_nhds.add rw obtain have rwa


rcases suffices refine convert rw intro simpa


rw refine exact simp intro rcases refine simp_all exact


cases classical have ext exact rw fun_prop


suffices rcases simpa apply refine rcases have tendsto_const_nhds.add rw have rcases refine simp apply simpa


therefore obtain have intro apply rintro simp exact have intro have have simp_rw apply rw exact exact rw filter_upwards exact have intro have invFun left_inv right_inv exact apply


ext refine rintro lift exact rintro refine rintro exact


refine have refine simp exact rintro let invFun left_inv right_inv map_add map_smul refine ext exact


constructor rintro have rw simp rintro simp


by_cases obtain rw change ext simp suffices contrapose rcases use ext dsimp rw simp


refine rw intro rcases have mem_compl_singleton_iff.mpr have refine mem_of_superset by_cases rw exact rw by_contra suffices rw exact notMem_compl_iff.mpr refine rw exact calc map_id.symm conv_rhs congr ext rw


by_cases rw rw exact have le_antisymm have rw exact have rw exact let have rfl suffices rw exact have refine unique_topology_of_t2 rw exact simp_rw exact


letI letI suffices intro induction zero rw exact succ haveI have intro letI let have have rw exact have exact have exact have intro by_cases rw rw exact have have rw have le_antisymm rw exact have exact rw intro change exact


ext constructor rintro exact rintro exact


LinearPMap.closureHasCore

refine congr ext simp intro exact let have rw exact


rw apply simp apply have have simp rw apply


constructor intro rw intro simp rw have rw rw apply simp exact exact intro use exact


Convex.locPathConnectedSpace

refine let let refine exact refine exact


letI haveI have rw rcases refine subset_add_left simp_rw simp_rw exact


apply rw sense, topology a apply this exact that on exact


have letI have isOpenQuotientMap_of_surjectiveₛₗ intro exact


IsModuleTopology.instProd

constructor have have refine le_antisymm sInf_le let let have have let rw change let let rw ext fun_prop


IsModuleTopology.instPi

induction exact infer_instance let suffices suffices have infer_instance


classical cases have ext nth_rw simp_rw refine rw push_cast simp rw haveI fun_prop


ContinuousMultilinearMap.completeSpace

classical wlog rw exact intro use simp have rw simp apply_rules exact exact isClosed_iInter isClosed_iInter exact isClosed_iInter isClosed_iInter


refine let obtain have apply exact have simp simp exact


intro filter_upwards rw intro rcases exact


refine simp_rw intro rw filter_upwards rw intro simpa


UniformConvergenceCLM.completeSpace

wlog rw exacts rw apply have convert exact


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


obtain simp refine letI set map_add refine simpa


refine exact rintro exact rintro use rw exact union_subset intro have rw rcases rw exact


set set have have eventually_map.mpr have rw exact have rw exact exact


obtain obtain by_cases obtain cases obtain simpa


constructor intro change rw letI constructor intro exact intro simpa rintro apply apply apply ext letI rw constructor rcases exact rcases rw exact


rw constructor intro rw apply intro obtain use refine cases exfalso exact rw apply apply


rw constructor rintro rw simpa intros constructor simp intro use simp


let prod_self_subset simpa use rintro have simp rw exact


obtain obtain use simp intro by_contra have have rw refine simpa


apply rw exact union_subset intro have rcases have exact h6


rcases rcases use constructor simp simp exact exact


rcases let mul_mem rcases rcases apply use rw exact one_mem apply use simp inv_mem rcases apply use rw simpa have refine rw exact use have induction zero succ rw exact have intro rw use rw apply


cases refine rw exact refine rcases rcases rw refine rwa


Subgroup.instDiscreteTopologyZMultiples

wlog specialize rwa rcases rw exact rw refine ext constructor simp intro rw simp simp_all


Subgroup.instIsCyclicOfDiscreteTopology

nontriviality exact have false_of_nontrivial_of_subsingleton


nontriviality rw constructor rintro infer_instance have simp refine obtain have exact


have refine rcases refine exact apply refine refine simp calc norm exact exact


rw have convert simp_rw apply filter_upwards filter_upwards simp exact


set have have apply filter_upwards exact


rcases simp rcases have simp simp have simp


refine cases ofNat left simpa negSucc have exact rcases simp exact exact


rw constructor all_goals intro filter_upwards rw rw rwa rw rwa


change rw rintro rcases rw constructor refine rw exact simp refine simp replace refine exact


refine wlog simp rcases simpa have simpa rw apply intro obtain have simpa rcases suffices rcases have lia rcases refine simpa use simp exact


have have have have le_limsup_of_frequently_le refine refine replace have have apply exact


have have refine filter_upwards apply rcases apply exact exact


have have apply mul_le_of_forall_lt_of_nonneg intro refine filter_upwards eventually_lt_of_lt_liminf exact


rcases simp simp rcases refine refine simp exact refine simp exact


rcases have apply simp rcases refine simp simp exact apply exact exact


revert rintro rw simpa intro rw simpa intro rw refine refine simpa


obtain rw split_ifs rw obtain rw positivity rw one_pow, apply rw mul_comm, intro simp_rw obtain rw lift rw refine obtain exact


obtain apply calc gcongr apply exact rw refine split_ifs exact


instLocallyCompactSpacePontryaginDual

let have refine rintro have rwa refine intro rw rwa lt_div_iff₀ apply rw refine gcongr exact rw refine rw refine rw refine exact_mod_cast


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


rw refine congrm exact and_iff_right_of_imp tendsto_nhds_unique


rw set let have rw convert ext simp rw all_goals


let have refine let have exact have rw exact rw let have have have rw exact


let have have subset_antisymm rw have exact


constructor intro rw refine isProperMap_iff_isCompact_preimage.2 let have let have have ext simp singleton_prod, constructor exact rintro exact have this fin.isCompact_biUnion exact this.of_isClosed_subset preimage_mono intro intro apply have have simp_rw ext exact rintro exact exact


rw convert ext refine by_cases exact exact


refine simp_rw rintro set have have rcases rw nhds_prod_eq, exact


refine simp_rw intro set have rw change simp let have simp_rw nhds_pi] exact


rw intro set have rw exact have have have rw exact continuous_inclusion continuous_rng_of_principal.mpr


obtain have rw gcongr rw exact have have rw exact


ENNReal.instContinuousAdd

refine rintro exact rcases exact simp tendsto_add]


let rsuffices obtain use have apply refine rintro exact rintro exact have apply refine rwa rintro refine rw apply rw exact refine refine obtain rw apply convert exact refine exacts rw exact


let letI mul_assoc haveI haveI have obtain exact


apply rw induction mem obtain exact simp_rw exact algebraMap add mul


obtain classical let let refine exact exact have rw exact replace simp suffices refine specialize contrapose simp intro simp exact


refine apply intro rw apply have simp rw apply apply haveI apply rw have by_contra exact rw norm_cast rw exact


by_cases rw dsimp norm_cast simp conv_lhs rw exact exact


haveI let let change have have have rw apply rw exact have have rw rintro rw rw dsimp rw rw replace rwa


letI haveI suffices constructor rw change simp


induction zero simp exact succ have replace suffices exact


constructor intro obtain have simp obtain rw refine rintro replace simp obtain simp refine convert rw rw simpa intro rw intro obtain have obtain have refine have ext simp simp intro exact


constructor refine suffices rintro rcases rw exact simp simp wlog specialize refine rw intro simp generalize_proofs rcases exact have refine rw simp intro obtain rcases rw exact simp have have have simp let have specialize intro simp split_ifs exact refine push_neg refine simp intro simp intro use split_ifs simp_all obtain classical refine refine push_neg exact intro simp obtain intro have simp obtain use split_ifs simp simp simp rw simp


lift rcases obtain specialize simp simpa rw obtain specialize simp simp


simp mem_nhds_zero, use contrapose obtain exact


rw apply simp_rw constructor intro exact rintro exact


have continuous_iff_continuousAt.2 have refine exact exact ext simpa simpa


have have have have have intro apply rw exact have rw show calc v


ValuedRing.separated

suffices apply intro refine rw have let exact


rw intro rcases rw intro rw use have rw apply


refine intro simp not_lt] simp refine obtain simp refine intro simp


refine intro rcases refine erw exact have have rw exact convert ext rw obtain rwa have have rw conv congr rfl rfl rw refine convert exact rcases let have use constructor rintro rw exact rintro apply rcases have have intro simp have intro simp have rw rw exact have rcases refine rintro exact rcases have refine rw filter_upwards rcases have apply have rw mul_one] solve_by_elim calc v


constructor induction by_cases simp simp rcases simp convert ext simp exact exact


refine simp_rw true_and, intro obtain use rw h.orderRingIso.apply_symm_apply simpa


induction isOpen compl obtain use exact iUnion choose exact


let refine let have finiteness to have intro have rcases rw obtain nhds_basis_closedEBall.mem_iff.1 refine show exact show exact show calc edist show exact hr edist choose refine ball limit let let let have intro induction zero succ have have intro cases zero succ have have intro rw have have calc closedEBall exact have rcases use simp have intro refine exact exact have intro refine refine exact constructor show intro have exact change exact


induction empty insert simp refine exact


constructor intro obtain choose have have exact


Topology.IsOpenEmbedding.baireSpace

constructor intro let let have have rw have calc grind have have ext simp refine exact exact


constructor rw rintro refine exact rintro exact


let have have refine rw exact refine rintro rw rcases exact


constructor intro rw intro obtain rcases have refine rw exact choose use refine exact have simp exact of have exact


have convert infer_instance exact have have exact


subst refine rintro exact rw exact rintro exact rw exact


change rw simp rintro let exact le_principal_iff.2 rcases exact


refine simp rcases exact intro rcases lift rcases exact


cases infer_instance obtain refine simp_rw intro obtain s_dense.inter_open_nonempty refine rwa


choose haveI nontriviality classical set refine rcases have choose lift refine simp exact


classical rcases rw exact choose haveI set refine rcases rsuffices exact suffices choose refine simpa intro exact


IsTopologicalBasis.iInf

let refine rintro refine intro rcases refine exact exact exact


classical refine rintro obtain simp by_cases rw exact rw exact


let choose haveI refine rintro rcases exact


have choose obtain apply rintro exact refine simp rintro exact rw apply intro simp grind simp grind


have ht.exists_countable_biUnion_of_isOpen choose refine apply simp have grind intro simp obtain have convert exact obtain refine apply exact


let have obtain have simpa choose refine apply intro exact apply apply simp intro rw apply exact rw apply intro rw change apply apply intro apply simp grind


TopologicalSpace.IsTopologicalBasis.sum

apply rintro exact exact rintro obtain hs.exists_subset_of_mem_open exact obtain ht.exists_subset_of_mem_open exact


apply rintro apply intro obtain let have have obtain have exact


induction zero by_cases simp simp_rw simp succ hn have intro simp obtain rw apply use exact


apply apply exact apply apply apply apply exact apply refine rw apply induction hz hi obtain apply apply apply rw apply exact apply exact exact


obtain rw refine simp_rw iUnion_subtype apply apply intro rw exact


rw refine intro induction hz rw exact hi specialize rcases rw exact exact


induction hz hi classical obtain choose let use intro specialize simp rcases exact obtain rw rcases specialize simp_rw refine simp exact right use simp exact


simp_rw apply intro simp_rw obtain exact


obtain apply rw apply intro simp obtain exact


simp_rw refine intro apply intro simp_all exact


rw by_contra rw rcases suffices rwa exact


have have simp rcases have by_contra exact let invFun left_inv right_inv rw exact


constructor intro let let have exact rw apply


let have rw intro rw exact refine ext apply ext apply


ext simp have simp rw simp apply congr rw simp simp erw rfl


constructor dsimp contrapose rintro let have let have have rw rintro exact obtain haveI haveI let let ofHom let have rw ext simp apply_fun dsimp simp exact rw apply


rw constructor intro by_contra specialize rw contradiction intro specialize rcases exacts


Compactum.instCompactSpaceA

constructor rw intro refine rw intro exact


ext constructor intro constructor exacts rintro exact


rintro let let let let let let let have rintro use simp exact have rintro obtain use simpa have rintro have rcases refine rw simpa suffices obtain use have rw exact have have have suffices intro rcases exact rcases exact intro exact intro suffices apply intro exact


let let let let let let let intro have intro by_contra rw specialize rw contradiction have intro exact claim1 have rintro exact have rintro rcases exact have rintro exact have suffices intro rcases exact rcases exact intro apply constructor use refine ext refine intro apply exact exact suffices obtain have have refine apply rintro exact simp intro refine intro exact


ext rw constructor rintro exact rintro exact


constructor dsimp contrapose rintro let have let have refine rintro exact have obtain classical let let let have rw ext dsimp rw refine simp apply_fun dsimp rw exact rw apply


rw refine refine apply intro refine refine refine simp exact exact intro obtain exact


have let have have rw simp rintro rw let g have have intro rw obtain have simp_all obtain exists_clopen_partition_of_clopen_cover have intro simp obtain grind have univ_subset_iff.mp have rw exact refine rw intro convert ext simp ext have obtain simpa ext simp


refine rintro rfl simp assumption_mod_cast simp assumption_mod_cast simp rw exact


have rotate_left intro change apply rintro refine continuity obtain clear let let have have intro exact have dsimp rw rintro refine dsimp rwa have obtain classical obtain let let refine apply intro dsimp rw exact ext constructor intro simp_rw obtain refine rwa intro simp_rw obtain rw refine rw rwa


let have obtain classical use apply simp exact


cases let let have choose let obtain have let let let refine have rw have rw congr ext1 change rw dsimp ext1 change rw


inhabit obtain classical let let refine ext simp dsimp have change rw rfl have rw swap assumption apply_fun rw exact intro have dsimp rw split_ifs exact exact


let let cases suffices refine refine convert ext exact ext exact by_contra haveI haveI haveI have suffices let have have exact let obtain refine ext1 apply_fun dsimp rw rfl


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


ext refine obtain refine rw obtain dsimp rw refine rw


refine ext rw by_cases exact rcases rcases simp refine rcases exact ext exact


change rw split_ifs simp apply simp rintro exact simp push_neg convert dsimp simp


intro by_contra apply suffices rw exact ext rw simpa


refine rw rintro let suffices apply intro dsimp by_cases apply exact simp suffices rw exact rintro exact


by_contra apply suffices ext simp contrapose exact


intro rw exact linearIndepOn_iUnion_of_directed


refine have rw refine exact exact linearIndependent_comp_of_eval


Profinite.Nobeling.isClosedEmbedding

apply dsimp refine intro rw refine rintro refine convert ext simp refine convert ext simp intro by_contra obtain apply dsimp rw exact


let refine intro ext by_cases exact simp


intro rw use ext change simp spanFinBasis, ne_eq, split_ifs


rw apply simp rintro dsimp split_ifs rw rw simp


rw apply simp obtain cases rw refine rw refine rw rw


apply intro have dsimp rw apply apply have apply simpa refine simp


rw refine rw rintro rw let dsimp suffices l.SortedGT from rw induction nil intro apply exact cons rw intro specialize rw simp obtain rw have dsimp split_ifs rw exact noncomm_ring rw apply apply intro apply apply refine simp have refine cases nil cons apply rw exact apply exact


obtain convert dsimp ext split_ifs rw simpa simp specialize intro contrapose exact


intro ext dsimp simp congr ext dsimp apply simp intro exact


ext simp intro rcases specialize rw simp exact simp rw rw


ext dsimp split_ifs rw rw rfl simp have specialize rw simp exact


dsimp simp let have let have refine rintro simp rw refine rwa intro simpa ext rw rcases have simpa simp have simpa simp congr simp exact


ext simp refine by_cases exact left intro apply have simp simp have intro refine rw rintro contradiction rwa refine have rwa


rw have have simp refine have simp exact rwa


have rw ext simp rw simp have intro simp rintro exact have apply simp split_ifs rw rfl simp push_neg push_neg


have rw simp refine refine by_cases rw simp have rw exact


have by_cases rw exact rw apply rw simp exact


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


rintro simp use obtain refine use ext rw rw projRestricts_comp_projRestrict rfl


refine use have simp exact refine have intro simp exact rwa


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


apply intro let let let let have rw assumption obtain refine ext apply_fun exact


refine dsimp intro by_contra let have let have obtain classical let let have rw ext apply change ite rw refine mt simpa apply_fun change rw exact


CompHaus.Gleason

constructor intro change infer_instance intro let change apply


suffices rw rfl constructor intro infer_instance apply


TopCat.isLimitConeOfForget

refine rw dsimp rw intro rw convert exact


let let let have apply dsimp conv_rhs simp


let let let have apply dsimp simp conv_rhs rfl


classical convert exact ext constructor rintro let refine simp rintro simpa simp rintro obtain let let let refine have intro induction empty intro simpa insert intro rw refine intro exact hh5 refine intro dsimp rw exact rw change rw apply ext1 rw apply ext1 simp


TopCat.partialSections.nonempty

classical cases exact haveI use rintro dsimp rwa


TopCat.partialSections.directed

classical intro let let refine rintro have apply rw exact exact rintro have apply rw exact exact


ext constructor rintro simp_rw rintro use apply rintro rw erw rw exact rw erw rw exact


TopCat.binaryCofanIsColimit

refine continuity intro ext rfl intro ext rfl intro ext exacts


classical constructor rintro rw show dsimp refine rw conv_rhs erw rintro have rw exact refine intro refine exact rw intro by_cases revert apply rw convert_to ext exact continuity exact revert apply rw have rintro rwa convert_to ext exact apply exact apply continuity rw exact change rw exact intro ext dsimp rw conv_lhs intro ext dsimp rw exact rintro have rwa rintro ext change split_ifs


ext constructor rintro simp simp rintro use apply rintro cat_disch


ext constructor rintro simp rw simp exact rintro have apply rw use apply rintro simp simp simp


ext constructor rintro use exact rintro use rw


constructor apply rw apply apply exact apply exact


ext constructor rintro exact rintro refine simp convert rw rw


rw constructor intro exact rintro rw exact exact


obtain obtain constructor exact intro refine dsimp rwa


ext constructor rintro exact rintro exact


ext constructor rintro exact intro exact


choose rcases classical use rw refine rcases exact exact


constructor rintro exact intro rw intro exact


constructor intro exact refine obtain exact


have frequently_inf_principal.trans rw congr tauto


constructor intro by_contra rw simp_all rintro exact exact


rw constructor intro simp intro simp_rw simpa


refine rcases rw suffices refine specialize simp_all


refine rcases choose have simp rintro exact rcases refine intro rcases exact refine exact rcases filter_upwards mem_interior_iff_mem_nhds.mpr f exact


simp_rw rintro obtain generalized_tube_lemma refine rintro exact


constructor rintro exact intro choose have f rintro haveI haveI have have exact refine rw intro rw exact


have f_cont.comp simp_rw refine conv exact


let have intro obtain exact let have rw exact exact


refine rintro refine simp rintro refine simp


suffices have rw principal_singleton, exact refine induction exact exact exact rw apply


cases infty rw refine have simp grind rw apply coe refine have replace simpa simp grind rw apply


onePointEquivSphereOfFinrankEq

classical have let have have have have letI exact


rw change simp constructor intro exact rintro exact


instTotallyDisconnectedSpaceUltrafilter

rw intro simp intro rw intro rw let have exact


have rw rw generalize generalize induction rel exact let preStoneCechCompat refl symm trans


obtain choose have subst obtain classical refine refine simp intro simpa apply rintro obtain rw exact


constructor exact rintro constructor exact exact


refine rcases replace apply rintro exact


intro have obtain haveI use have convert rw ac_rfl exact


rcases hs.elim_finite_subcover mem_iUnion.2 refine rcases refine exact


refine choose choose rcases refine rw exact


let suffices simp apply push_neg simp refine rcases exact


obtain suffices by_contra replace have refine rcases refine have contradiction


rw intro by_contra have choose obtain h have have have exact


intro by_cases exact simp rcases rcases have filter_upwards rcases exacts mem_image_of_mem rcases exact


IsCompact.prod

rw intro obtain hs obtain ht rw refine rw


obtain hu.elim_finite_subcover use exact ext simp intro obtain simp_all


simp intro have refine exact choose exact


constructor intro exact intro choose exact


let obtain zorn_subset by_cases obtain haveI obtain use refine exact exact convert_to ext simp apply rintro obtain exact exact exact exact use refine rw exact obtain refine intro have refine exact simp rw


instUCompactlyGeneratedSpaceSum

refine all_goals let have exact let have exact


refine let change have rw exact apply simp exact exact


instCompactlyGeneratedSpaceSigma

refine compactlyGeneratedSpace_of_isClosed isClosed_sigma_iff.2 let have exact


refine rw intro rcases exact isClosed_iff_forall_filter.1


ext refine forall_congr refine exact exact


intro have obtain haveI use have convert rw ac_rfl exact


have s intro exact have intro choose refine refine simp exact have intro let refine simp exact exact


have hs.elim_countable_subcover mem_iUnion.2 rcases use apply apply intro apply exact


let refine constructor intro simp tauto have rwa


obtain rcases simp simp obtain refine intro obtain exact


refine choose choose rcases refine rw exact


let have have simp rw apply simp apply exact rcases use rw simp exact


apply intro have have choose use constructor refine exact refine intro simp intro exact


constructor rintro obtain choose have subst obtain refine refine simp intro rw exact apply rintro obtain exact rintro constructor exact exact


intro by_cases exact simp rcases rcases have filter_upwards rcases exacts mem_image_of_mem rcases exact


obtain rcases simp_rw simp obtain use rwa


Topology.IsInducing.locallyCompactSpace

rcases have have rw exact refine rw exacts


choose rcases refine rintro rcases exact


have simp choose choose choose refine exact simp exact refine simp rintro exact simp rintro exact


have apply simp_rw apply rcases refine simp exact


classical set set set interior have simpa have have choose have choose set refine rintro exact refine rcases exact intro refine have apply rintro simp rintro refine have contrapose exact


have open choose rcases refine disjoint_compl_right.mono rw refine exact refine rcases this simp_rw exact exact


constructor exact rintro refine intro have rw exact apply calc


instSigmaCompactSpaceSigmaOfCountable

cases infer_instance rcases refine refine exact simp intro rcases refine exact


suffices refine intro rcases exact exact


rintro have rcases exact cases inl rcases have exact inr rcases have exact


let have induction refl refine rw exact obtain refine rw refine rw exact refine intro obtain obtain obtain exact


have have ht.out have refine exact reflTransGen_of_succ


IsPreconnected.image

rintro rcases rcases replace rw replace rw exact obtain refine exacts rw v'_eq] exact


refine rintro rcases rcases replace rcases exact


specialize obtain exact replace simp_rw exact


have intro by_cases exact right intro exact apply exact


rintro classical rcases induction empty refine simpa insert rw have refine set have refine rwa exact have have have refine exact


have refine rwa have rw exact have rw refine rw


constructor rintro exact rintro haveI exact


constructor intro exact intro rcases exact exact


refine obtain exact obtain exact rintro exact


refine obtain have refine exact exact have refine exact exact rintro exact exact


refine obtain exact obtain exact exact rintro exact exact


rw by_contra replace simpa rcases exact rw exact


let have apply rcases exact have apply filter_upwards exact have have change simp


let change have apply rintro have rwa rintro exact


constructor intro specialize contrapose simp rcases have have exact intro by_contra specialize apply rcases rcases exact rcases exact


rw classical refine induction empty insert simp sUnion_insert, refine refine exact exact simpa rw have simpa


constructor intro rw specialize contrapose simp rcases have have exact rw intro by_contra specialize apply rcases rcases exact rcases exact


refine apply rw have rw simp apply rw exact rwa


have refine have rw intro let let have intro apply exact rw have apply rw refine rw exact rintro constructor exact refine exact uv_disj.subset_compl_right have apply rw refine rw exact rintro constructor exact refine exact uv_disj.subset_compl_left have have have rw rcases left right have refine rw rcases h left rw suffices exact right rw suffices exact


unfold by_contra have have apply rw exact exact simpa


refine have exact pathComponentIn_subset.trans


Sum.locPathConnectedSpace

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


Sigma.locPathConnectedSpace

rw refine apply exact exact exact exact exact


apply simp intro exists intro symm apply


simp_rw refine constructor intro rcases exact exact let


constructor intro exact intro rw refine h exact


constructor rw intro rcases exact rw refine rw rcases exact


refine obtain simp isOpen_connectedComponent]


refine rintro choose have have have refine simpa exact


ext constructor intro rw exact intro rw exact


cases simp obtain induction h0 simp use simp hp₂ simp obtain specialize obtain obtain rw use simp tauto


letI constructor intro refine rintro exact unfold rintro exact


constructor intro apply exact exact intro intro rcases exact exact


rw refine rw image_preimage_eq refine rw exact


rintro have simpa have simpa image_preimage_inter]


induction open_retrocompact exact union compl rw exact


induction open_retrocompact hUcomp have simpa suffices simpa rintro rw exact hfcomp union compl rw exact


induction isSublattice exact bot_mem top_mem sdiff hV have obtain obtain simp_rw induction empty simp_rw exact union sup


Topology.IsLocallyConstructible.inter

rintro obtain obtain refine change exact


Topology.IsLocallyConstructible.union

rintro obtain obtain refine have ext rw exact


have have have have have have rwa choose obtain convert apply rw exact exact


intro have have refine let convert ext simp


ext rw constructor rintro exact rintro exact


choose refine rw intro subst refine exact obtain simpa


rw simp_rw refine rintro refine simp_rw exact exact rintro classical refine by_cases use simp_rw exact use simp_rw exact rw simp


cases rw simp_rw refine rintro refine rw exact exact


refine apply rintro letI exact classical refine refine simp


cases rw refine exact rintro letI refine choose refine classical rw refine by_cases


refine rcases refine simpa refine rw rcases filter_upwards simpa


simp intro obtain exact mem_nhds_prod_iff'.mpr disjoint_of_disjoint_of_mem


rcases simp have constructor intro refine simpa simpa intro simp exact


constructor intro exact rintro rw convert ext simp


Topology.IsInducing.sumElim

rw rw rw intro apply obtain simp sup_le_iff, convert rw rw exact rw exact


rcases have rw have rw image_univ] exact exact


simp_rw constructor intro exact intro refine exact


by_cases obtain refine by_cases exact simp suffices rwa


using have let refine haveI refine rw exact let rw exact


fconstructor intro exact by_cases exact rintro convert apply rw exact


refine rcases simp exact simp lift calc dist refine rw exact refine calc dist rw


classical refine lift have intro ext1 simp simpa


refine apply rw apply intro contrapose simp simp ext simpa


ext simp sup_of_le_left] rcases simp simp


refine by_contra rcases exact obtain by_contra exact


suffices refine le_antisymm refine lift replace simp_rw norm_cast set have have refine simpa and suffices obtain refine rw refine simp by_cases simpa sub_self, refine have calc simp simp one_smul] calc simpa mul_le_mul_right neighborhood this have refine refine convert ext simp rintro rintro refine convert ext simp rcases simpa simpa intro replace rw obtain have refine convert ext simp star_def] simp rfl compactness obtain obtain t.eq_empty_or_nonempty.elim let obtain refine convert ext simp


refine let rw simp_rw obtain exists_continuous_zero_one_of_isClosed exact simpa simpa


refine contrapose rcases exists_continuous_zero_one_of_isClosed rw use simpa obtain refine simpa


ContinuousMap.concat

by_cases let suffices apply rintro simpa exact


rw rintro have let let have have have rw apply rintro simpa have rw apply rintro simpa filter_upwards by_cases rw refine simp replace rw refine simp


intro by_cases convert have simp_rw simp rw simp


ext fconstructor rintro rw dsimp let refine simp ext simp convert ext simp replace field change rw have have have fconstructor exact rw exact rintro let refine simp ext simp


refine rintro rw refine rw exact rw exact rw exact


apply apply_rules intro exact refine simp intro simp obtain rw obtain refine rwa rw obtain have intro rcases rcases exact choose rcases refine rw exact have simp exact refine refine exact


apply have set use refine simp rintro exact intro obtain rw exact lift lift rcases refine rw exacts rw exact


refine intro constructor rw intro use ext simpa rintro exact


rw rintro refine simp by_cases swap exact and as dsimp choose let have intro refine apply rw exact let let have let have intro obtain dsimp simp exact have simp let have intro refine apply dsimp rw exact let let have let refine rw intro rw simp fconstructor dsimp simp exact dsimp simp rintro apply


apply let have convert sublattice_closure_eq_top simp


let let have intro obtain simp use refine use simp obtain hsep obtain use intro have rw exact


intro obtain let f const have refine ext1 simp refine rw convert ext1 simp simpa


rw let have let have haveI congr_arg rw have have exact h₁.trans intro let let have have key have rw convert ext apply simp


refine rw induction mem push rw obtain all_goals algebraMap add mul


intro induction mem obtain rfl add zero mul smul rw rw star rw rw


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


refine simpa closure_inter_subset_inter_closure intro rw have conv exact refine filter_upwards


refine induction mem push rw obtain all_goals zero add mul smul


induction zero id star_id add mul smul frequently


apply rw exact intro rw apply simp exact


refine continuous_induced_rng.2 have simp simp exact


apply rintro refine apply rintro rw use ext simp


rcases let let have have apply_fun simp rw rw exact subsingleton


ZeroAtInftyContinuousMap.bounded

obtain mem_cocompact.mp obtain refine have intro by_cases exact exact exact


refine rw have refine obtain refine calc dist exact


have intro rw simp constructor rintro exact rw


rw constructor intro rcases rw apply intro refine rw


have from choose h e.2 have let have have mem_iUnion_of_mem have cases exact have let have have hU.inter isOpen_iInter_of_finite exact have have refine hU'.trivializationDiscrete convert simp_rw have hs.trans rw inter_comm] convert refine have rwa convert


have have ext obtain intro have refine hf.isOpen_preimage.mp disjoint_iff_inf_le.mpr preim_im.subset rw exact convert ext have obtain refine apply apply rintro rw have rw apply rintro simp_rw


letI suffices choose rintro have refine mem_interior_iff_mem_nhds.mpr rw exact


refine suffices clear refine rintro exact


set haveI suffices simpa intro set have filter_upwards rintro rwa obtain simpa suffices rintro have apply use tauto


rw intro refine obtain have rw exact obtain exact obtain suffices replace exact


by_cases apply simp simp trans apply rw exact exact exact obtain simp_all


ext simp constructor refine ext simpa exact


rw congrm rw constructor by_cases exacts refine simpa


rw obtain use constructor rw exact tauto_set


rw constructor intro obtain use by_cases rw simp rw simp intro obtain use simp


wlog rw exact let have monotone_nat_of_le_succ have simpa


constructor rintro rw exact rintro dsimp rw rintro exact


obtain v lt_iSup_iff.mp have apply exact exact


rcases let refine calc gcongr apply have let have let have apply rcases grind have have grind grind refine rcases calc rw exact rw gcongr exact calc congr congr grind have have simp grind congr grind exact refine have have have rw add_zero, exact rw


by_cases simp have by_cases simp have refine sequence variations. rintro let calc dsimp congr grind grind congr rw convert rw gcongr exact


eVariationOn.union

classical apply apply rintro obtain x eVariationOn.add_point obtain calc huv refine apply rcases have apply rw exact rw exact apply rcases have apply exact rw rw exact


eVariationOn.sum

induction zero succ by_cases simp rw rw apply apply apply


refine rintro rw refine le_iSup_of_le φst le_rfl rw dsimp rw congr


apply cases convert exact let have have have change rw exact


rcases convert apply rintro rcases rcases exact rw exact rw exact rintro exact rw exacts


apply rintro calc refine simp rw exact rw intro exact apply exact


variationOnFromTo.add

symm refine rintro simp rintro rw variationOnFromTo.eq_of_le eVariationOn.Icc_add_Icc


rintro rw calc f rw apply apply exacts rw


refine constructor rintro rcases exact exact


refine constructor rintro rcases rcases exact exact


have calc edist gcongr exacts refine rw rcases calc edist exact have rwa calc edist


simp nhds_subtype_eq_comap_nhdsWithin, congr constructor rintro exact rintro exact


rintro refine replace obtain rw rcases have have inter_mem filter_upwards calc edist edist edist_triangle4 gcongr refine exact exact exact


by_cases simp exact rw have have simp exact


induction zero succ by_cases refine apply simp


induction zero succ by_cases have lia apply suffices rwa


unfold rw intro by_cases simp apply exact exact simp


wlog simp unfold grw conv_lhs grw gcongr grw gcongr unfold rw intro exact


obtain have wlog convert convert simp have exact simp obtain grw


rw rw have let let obtain apply simpa wlog have have by_contra simp have refine dsimp grw rfl apply suffices rw apply simp have simpa have rw have simp simp exact simp true_and, have simp grw have simp apply apply nth_rw rw congr rw rw gcongr exact have have have edist simp apply apply exact refine refine exact rw apply rw apply


classical rcases rcases simp simp obtain rw refine suffices refine conv_rhs exact rwa simp_all exact iSup_edist_pairSet


Metric.instParacompactSpace

the have have have simp refine simp obtain let have have set hD have eball simp rw have y rw simp have obtain rcases have rcases refine simpa by_contra apply exact memD.2 have rw iterate exact have rw rintro refine norm_num1 refine refine rcases exact intro rcases have rcases set refine have rw rintro rcases have apply calc edist rw have rintro by_contra wlog exact rcases rcases suffices calc edist rw have refine simp refine exact


set intro suffices simpa intro obtain have rcases exact suffices rintro haveI have have have exact


StoneCech.projective

intro let have let have let have refine rw


refine let let let have have have have let have have intro by_cases exact exact haveI obtain let have have suffices rw exact rw refine intro have rcases exact exact rw exact


let suffices rcases obtain refine intro contrapose exact eq_univ_of_image_val_eq intro refine mem_iInter.mp by_cases refine eq_univ_of_forall inter_nonempty_iff_exists_left.mp refine iInter_inter replace have exact rw exact all_goals rw


by_cases simpa intro rw intro rcases have have have rcases have rcases have exact


intro let have isCompact_iff_compactSpace.mp let have have rcases let have have exact let let have refine suffices ext exact


instExtremallyDisconnected

constructor intro rw intro rcases suffices rw exact apply intro rw intro by_cases rwa rw exact fun_prop


obtain rcases exact set have have have have set have have obtain rcases rwa refine of obtain obtain obtain refine exact done. rcases exact rsuffices exact obtain have by_cases a obtain refine rcases exacts rw push_neg rcases exact


constructor ext simp rfl rintro simp simp


apply simp refine ext simp mem_localTrivAsPartialEquiv_source,


refine have refine exact apply simp have refine exact


letI obtain continuousOn_iff'.mp rw exact


letI intro let refine exact exact refine rw exact rw exact


rw coe_fst by_cases simp refine exact simp rw exact


refine continuous_snd.comp fun_prop exact intro rwa


refine rintro rcases exact obtain exact rintro exact


rw simp_rw compl_iUnion₂, refine rw intro use rw exact hsub.trans


let have obtain simp simp refine rintro filter_upwards


intro rw intro obtain apply intro have rw exact


delta replace coequalizer.π coequalizer.π let have dsimp rw simp_all have this simp exact


constructor delta simp_rw intro rw rw change rw refine rintro obtain unfold rw erw erw exact rintro dsimp rw rw


ext constructor rintro obtain substs exact rintro refine rw exact


have ext conv_rhs simp rw symm apply rw exact


TopCat.GlueData.MkCore.t'

refine intro refine rcases exact fun_prop


intro rw rw rintro obtain use use constructor rw apply convert rw congr exact refine rw exact


ext constructor rintro obtain rw exact rintro rename_i exact


ext rw simp split_ifs have norm_num congr apply simp linarith congr apply simp linarith exfalso linarith


constructor intro apply rintro refine hequiv_unit invFun left_inv right_inv exact convert


simp split_ifs rw refine tauto rw linarith exact


GenLoop.homotopicTo

refine rintro rw all_goals fun_prop iterate intro ext dsimp rw swap apply apply intro ext dsimp rw apply rw


GenLoop.homotopicFrom

refine pick_goal rintro erw obtain simp rw exacts rw all_goals intro apply simp toLoop_apply_coe, first apply apply apply


by_cases refine rintro change apply simp loopHomeo_symm_apply]


rw intro obtain refine refine congr_fun t ext


choose let have refine obtain have refine have refine have let specialize uniq ext simp split_ifs apply simp simpa exact uniq let simpa uniq


obtain lift rcases refine simp rintro simp specialize hF_unique ext ext


refine intro rw exact intro haveI haveI exact


intro obtain refine obtain refine convert ext simp


constructor by_cases simp filter_upwards simp not_forall, tauto simp filter_upwards simp not_forall, tauto have filter_upwards simp apply by_cases simp apply simp simp apply simp


classical have convert by_cases simp exact simp exact


have obtain obtain rw have have rw set use simp_rw rw simp choose refine have have rw rw


rw constructor replace contrapose simpa exact exact


refine rw rintro constructor exact rw obtain refine have rw rw add_eq_right, exact


refine rintro exact rintro obtain refine convert rw apply


rcases simp rcases have rw exact exact have exact rw simp


rcases rw simpa constructor rintro refine rw pair_subset_iff] refine simp simp intro contrapose rcases have rw apply rcases simp_all


constructor rintro rw exact intro contrapose obtain rw xor_iff_not_iff'.1 rcases use rw exact exact


induction zero simp refine succ apply exact exact


simp rw rotate_left exact exact simp_rw exact


let let induction zero succ refine simpa simpa


simp intro induction zero simp exact succ simp use have simp specialize generalize fin_cases


by_contra rw let have have generalize clear wlog exact obtain clear have apply grind rw replace ofDigitsTerm ring_nf linarith simp pow_succ, replace rw linarith linarith


simp rw rw swap simpa apply rw simp rw exact exact exact exact


suffices rw have simp_rw exact suffices refine rw apply rintro simp nth_rw refine rw simp rfl


letI letI set have rw congr⟩ let let haveI rcases left let let have simpa ext1 rsuffices have rw erw rw convert exact rw rfl obtain exact let have rcases left ext1 convert exact right ext1 convert exact let convert simp rfl⟩ convert rintro use convert simp rfl⟩


rcases simp_rw exact refine rintro rcases rcases refine exact grw exact exact


rw refine filter_upwards refine rw rwa filter_upwards have rw rwa


rw constructor obtain h refine by_cases rw exact refine rw conv_lhs gcongr obtain exact


have refine rcases have refine exact induction top coe induction top simp simpa coe


classical induction empty insert simp apply right exact exact exact


induction zero succ simp_rw intro refine simp exact simp simp


rw obtain obtain obtain refine refine filter_upwards simp refine filter_upwards obtain obtain refine simp refine filter_upwards refine filter_upwards


refine rcases rw filter_upwards refine exacts


rcases simp refine exact apply rw calc sSup dist_le_diam_of_mem


have apply intro obtain exact have filter_upwards simp have rw simp_rw have rw rfl


have filter_upwards simp have rw simp_rw have rw rfl


refine refine rw rintro filter_upwards exact


refine refine rw rintro filter_upwards calc f


have have apply exact have apply rintro have have simp exact simpa


suffices filter_upwards suffices simpa exact


apply simp intro by_cases simp lift refine simp simp refine simp


refine by_cases simp refine filter_upwards exact refine refine by_cases refine rw simpa refine continuousOn_toReal.continuousAt simp_all


rcases rw have have le_limsup_of_frequently_le refine refine exact


rcases rw have replace replace h₂.imp_right refine filter_upwards apply rcases apply exact exact


replace refine exact replace refine exact refine refine exact


rcases induction exact exact simp exact exact exact simp exact exact


simp intro rw use split_ands intro simp rcases have rw exact exact simp rw


simp intro rw use split_ands intro simp rcases have apply rw apply simp have have have replace apply rw mul_div_right_comm] simp lt_max_iff, exact simp simp


rcases induction exact simp exact exact simp exact exact simp exact exact simp exact exact


have have rintro simp rcases refine rw refine simp


rcases rw positivity rw calc rw linarith


Rat.instTotallyDisconnectedSpace

clear refine by_contra wlog apply rcases have rw have exact


convert congr exact exact lemma lemma closure


rcases rw exact rw refine ext obtain simp


ext constructor intro exact intro refine have exact


IsPreirreducible.image

rintro rw rcases rcases have rw rw rcases refine all_goals rw apply show simp


classical refine induction empty insert rw rw exact simpa intro simpa


refine compl_surjective.forall.trans simp refine rw


simp refine simp_rw refine simp not_disjoint_iff_nonempty_inter]


obtain replace refine rintro classical obtain refine simp intro simp rcases exacts replace exact


rintro obtain obtain mem_closure_iff.mp obtain refine


obtain have obtain obtain exact have refine exact hV.2 rw exact


ext simp exists_prop] constructor rintro exact rintro exact


refine obtain exact obtain have refine rw obtain haveI exact mem_interior_iff_mem_nhds.mpr


refine simp_rw rintro obtain refine simpa ext


IsLocalHomeomorph.isTopologicalBasis

refine rintro refine rwa obtain refine ext apply rw f.source_inter_preimage_inv_preimage]


rw constructor simp_rw intro have refine nth_rw rw exact rw exact intro refine rw intro have rw exact


rw intro obtain nonempty_inter_closedPoints exact


JacobsonSpace.discreteTopology

have rw exact have rw intro rw refine rw trivial


refine rw intro rw obtain obtain refine by_cases convert_to ext apply convert continuous_subtype_val ext simp convert rw intro exact


refine intro induction nil cons ih suffices simpa exact intro rcases clear have induction nil exists simp exact cons rcases rcases exact rcases have refine have have refine replace simp exact refine exact


simp refine exact intro dsimp refine exact


induction nil cons simp_rw have rw exact


refine rw intro convert ext suffices exact


simp_rw constructor intro rw intro obtain simpa preimage_mem_comap


refine obtain have rwa obtain refine rwa


wlog let suffices have rw simpa refine fun_prop rw exact exact rw intro let have have let refine convert ext obtain simp rfl


simp_rw constructor rintro exact rintro exact


tfae_have rintro have nth_rw rw refine rw exact tfae_have h, tfae_have h, obtain obtain rw exact ht'⟩ tfae_have choose refine rintro exact exact tfae_have convert simpa tfae_finish


rintro rw intro by_cases exact rw rw exact


choose choose replace by_contra replace refine filter_upwards rintro calc f


have ext constructor exact intro rw tauto rw apply rw apply exact


rw constructor exact intro rw simp_rw exact


ext change simp_rw constructor rintro refine ext obtain constructor rintro obtain rw exact intro exact rintro refine simp_rw


rw refine constructor intro simp_rw exact simp_rw intro rcases exact


IsProperMap.prodMap

simp_rw constructor exact hf.1.prodMap hg.1 intro simp_rw rcases rcases refine rw exact


simp_rw constructor exact continuous_pi intro have choose refine rwa


constructor exact rw refine rw rcases refine rw exact


classical rw constructor rintro exact intro refine simp


constructor exact rw refine let closure have have this.mem_of_tendsto rcases refine rw rcases exact


constructor exact rw refine let have have this.mem_of_tendsto rcases refine rw rcases exact


rcases rw intro refine grw rw dsimp grw field_simp norm_num1


have rw intro rcases simp_rw refine filter_upwards tendsto_snd simp mem_setOf] grw constructor


contrapose obtain have intro apply rw replace exact exact


let have intro apply intro simp exact have apply intro exact obtain cauchySeq_tendsto_of_isComplete refine apply filter_upwards exact


refine have refine simp exact filter_upwards


PseudoMetric.IsUltra.finsetSup

constructor intro rcases simp simp_rw apply simp intro have simp refine


rintro refine dsimp ext induction zero succ simp refine contrapose simp refine rw refine rw apply rw apply


specialize rw obtain use intro rw apply apply rw linarith


rw rintro obtain rw refine rintro rw apply rw apply apply apply apply


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


CauchySeq.isCauSeq

obtain intro rcases simp exists intro rw apply apply


CauSeq.cauchySeq

refine rcases obtain exists simp constructor exists intro exists rintro dsimp rw apply rw apply


apply intro have exists rw intro obtain exists simpa


constructor intro let have rw specialize rw exact intro rcases rcases rw use intro rcases exact


rcases rsuffices exact let refine rcases exact have exact


rw rw conv have rw intro obtain exact exact


completeness, let have have finiteness in standard refine let let use have to points possible a intro obtain have intro obtain refine simp rw apply exact use simp exact have rcases use have mem_iInter.2 mem_closure_of_tendsto simp exact use rw exact have to approximated as intro have obtain simp obtain have obtain exact calc edist have hausdorffEDist_le_of_mem_edist refine have rw obtain exact


have ext refine rintro exact rw refine rcases rw exact refine refine rcases rcases refine rcases rcases have calc edist exact


refine refine apply_rules intro rw exact


constructor entourage, in closed intro rcases have rcases refine have refine have rw apply exact intro rw by_cases exact have simp exact simp exact that continuous is the also rintro let have have simp rcases refine have intro have exact lt_of_le_of_lt grind


refine try change trans apply exact trans exacts


haveI rcases refine convert simp convert rw rfl


refine try change trans apply apply trans exact apply


rw obtain simp refine refine simp obtain exact


simp obtain have let obtain refine refine simp exact rw simp_rw rfl


rcases simp have obtain exact let simp_rw simp_rw specialize obtain refine refine rwa rw


intro by_contra let have suffices refine simp constructor simp exact


simp intro let have simp gcongr refine apply simp calc edist rw gcongr exact simpa


rw rcases replace rcases simp simp exact


by_cases have e.surjective.forall₂.2 refine simp exact


rw constructor intro exact intro rcases refine exact


simp constructor rintro refine rintro exact exact exact exact rintro constructor


constructor rintro rcases rcases refine rintro exact cases cases exact rintro constructor


rcases rcases rcases simpa simp calc dist simpa rcases simp calc dist dist rcases simp calc dist dist simp calc dist dist


constructor rintro obtain refine rintro rcases simp exact apply calc refine obtain refine apply rw exact


Metric.Sigma.metricSpace

refine rintro simp rintro rcases simp simp abel rintro rcases simp intro apply calc


Metric.Sigma.completeSpace

set set have simp exact have refine convert simp


let let funext simp refine change rw rfl rfl exact


simp refine rcases have use rw rintro have have dsimp exact


in separable separable rcases let let let have have have let have have have have rw exact rw let have hausdorffDist_image rw let let have rw exact have rw exact refine simp intro rw exact apply exists


inhabit have hausdorffDist hausdorffDist hausdorffDist intro rcases rcases have rcases have rw have exact exists_dist_lt_of_hausdorffDist_lt q.isCompact.isBounded) rcases rcases rw have have calc diam diam_union rw gcongr let inl inr let dist have simp repeat exact calc exact calc exact exact exact calc have intro cases apply apply refine rw exact let have hausdorffDist_optimal_le_HD refine have intro have rcases exists_dist_lt_of_hausdorffDist_lt q.isCompact.isBounded) have rcases calc have intro have rcases exists_dist_lt_of_hausdorffDist_lt q.isCompact.isBounded) have rcases calc simp inequality have hausdorffDist intro by_cases exact calc hausdorffDist hausdorffDist_optimal_le_HD refine apply refine rintro exact exact


let let let refine exact exact rw hausdorffDist_optimal] exact


refine rcases rcases have let have have calc dist linarith let let let have have have have hausdorffDist have hausdorffDist_triangle have hausdorffDist hausdorffDist have hausdorffDist_triangle have rw have refine have refine intro rcases rw use exact intro rcases rcases use rw exact have rw rcases rcases have refine rcases exact linarith


refine let have have simpa choose let let let refine to and the composing have let let have refine show intro have obtain exact show intro have obtain let let have have have let use have have have have rw exact show intro let have have have simp let have have have simp have have rw have have simp have have rw rw rw have calc ε⁻¹ rw calc dist calc dist


GromovHausdorff.totallyBounded

is in it refine let have rcases have have simp exact le_of_lt have intro by_cases have use exact rcases rcases rw have obtain use simp choose let let refine infer_instance rintro have let let have refine show intro have rcases exact show intro have rcases let let have have have let use have have have have rw exact show intro have rw let have have have simp let have have have simp have calc refine refine change refine exact have calc refine refine change refine exact have have rw rw have rw have have rw have calc ε⁻¹| calc dist rw calc dist


have isClosed_eq have isClosed_eq have isClosed_eq have isClosed_le have have isClosed_le have candidatesB ext simp rw repeat first apply apply apply apply apply apply apply apply intro


obtain have obtain have hcf have ciSup_mono ciInf_mono have intro refine intro simpa change exact have refine intro simpa simpa simpa


refine rintro simp exact refine have tendsto_const_nhds.mul simpa rintro exact


refine have ciInf_le have calc dist gcongr exact have ciInf_le have calc dist gcongr exact


refine have rintro have have le_csSup have rcases exact refine inhabit rcases exact rintro have have le_csSup have rcases refine rwa


let obtain let let let have obtain exists_retractionCantorSet let have let have have exact


apply rw simp intro by_contra simpa by_contra rcases have exact


borelize refine contrapose have rw exact


refine refine exact refine rcases refine rcases exact


borelize refine have rw have contrapose finiteness rw exacts


borelize refine have rw contrapose exact


cases rwa exact rw have rw refine simp exact


have let have rw direction_affineSpan simp_rw simpa


refine refine have have obtain obtain calc infEDist


obtain let have by_contra have exact refine show refine have rw have have rcases simp exact show intro simp apply


rcases use simp obtain have rcases exact


rcases rcases refine intro exact intro exact


rw simp constructor change exact calc infEDist change exact calc infEDist


replace refine refine rcases rcases exact rw exact


rcases rcases rcases rcases have apply intro exists have rwa exact intro exists have rwa exact exact


rcases rwa rcases rwa have apply simpa simpa exact


apply intro rcases exact intro rcases exact


HolderOnWith.interpolate

intro calc edist simp nth_grw push_cast simp ring


obtain simpa have rw rw set set have have have simp congr simp rw exact


refine let iInf_lt_top.2 simp_rw let exact


constructor refine by_cases rw rw rw refine obtain h exact intro rcases exact rw congr simp


MemHolder.holderWith

intro by_cases simp rw on_goal have have rw refine rw exact


by_cases obtain rw exact rw obtain all_goals


by_cases rw simp by_cases refine rw rw refine rw exact rw rw rw intro exact


classical cases simp_rw rcases simp_rw exact


refine simp_rw rintro exact exact rw exact exact


refine refine rcases have simp have calc dist rw gcongr gcongr simp exact simpa


rcases use rcases haveI have rcases rcases exact


rw have choose rcases exact have apply use rintro simp_rw exact let refine rw exact intro ext exact


cannot the rcases exact have let have rcases refine rintro dsimp rw calc f have refine simpa refine rw refine rw calc g rw gcongr apply


have have exact choose refine exact ext1 exact


suffices apply mp_mem apply rintro simp exact intro rcases rcases filter_upwards hz apply calc edist


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


rcases obtain obtain rcases rcases refine apply


obtain have let choose hC.small_diam_splitting let induction nil cons cases use exact use exact let have refine intro cases exact exact have intro apply simp rw refine rw rcases dsimp cases convert rw convert rw have rintro exact exact have rw apply refine rintro exact apply fun_prop intro simpa


constructor intro apply intro rw exact intro rw exact intro rw exact


constructor intro by_contra exact intro exact


ext simp constructor rintro simpa intro refine rcases simp simp


constructor induction zero succ intro rw simp rcases exact rw exact induction zero succ simp refine exact


rcases simp rcases simp rcases simp simp pow_le_pow_iff_right₀,


rcases simp suffices constructor intro by_contra exact intro exact


constructor intro apply rw exact intro rcases simp rw apply rw exact


apply rintro apply intro obtain v x rcases refine intro suffices intro have rw simp exact


constructor intro obtain rw exact intro refine rcases obtain refine rw exact


PiNat.completeSpace

refine intro refine refine filter_upwards exact


rcases exact have obtain refine apply calc infDist rw exact


have rw classical have contrapose rw refine rw exact


by_cases exact have have rw classical obtain simpa refine rw rw


have rcases have have rw rw exact exact have have have rw exact rw exact


prefix of that length same length classical set have refine apply rintro by_cases rwa simpa intro rw exact mem_range_self refine rcases simp rcases simp have rw apply suffices simpa by_cases rw xs] by_cases rw have have have rw apply exact rwa by_cases have have have rw apply apply rw rwa have have have have simp_rw by_cases have rcases exact symm rw exact rw apply congr have rw exact have rw exact have rw exact


obtain exists_retraction_of_isClosed have exact


this balls and letI have have rcases let let have have refine refine rcases simp have have let have by_contra apply rw apply rw exact have rw have calc dist have have rcases exact choose have refine refine have calc dist have rw exact have refine have have rw exact refine nonempty_iInter_of_nonempty_biInter obtain clusterPt_principal_iff.1 have refine have rw rw apply apply obtain apply simpa exact


Metric.PiNatEmbed.separation

let obtain simp_all have obtain denseRange_iff.mp refine simp intro replace simpa have simpa


Topology.IsClosedEmbedding.polishSpace

letI letI haveI have rw exact infer_instance


PolishSpace.iInf

rcases rcases letI haveI inferInstance, hi₀⟩ letI haveI letI rw have htop.symm secondCountableTopology_iInf letI have htop.symm infer_instance


refine simp simp calc dist dist refine rcases exact rcases simp have refine refine rw exact simp exact


refine have refine exact exact obtain by_cases exact obtain refine rw calc have have rw have have rw exact have have ge_of_tendsto exact


IsClosed.isClopenable

topology classical haveI let haveI let have simp exact refine rw exact rw simp have have simp_rw simp rw simp


PolishSpace.IsClopenable.iUnion

choose obtain exists_polishSpace_forall_le have apply intro apply exact obtain exact


rcases exact have obtain have rcases exact


rcases rw exact rcases haveI refine rcases let refine let have simp exact


obtain hs.elim_finite_subcover let mem_iUnion.2 refine simpa


PseudoMetricSpace.ext

let obtain let obtain obtain congr ext rw exact ext rw


refine constructor rintro rcases exact exact


refine constructor rintro rcases rcases exact exact


simp refine rcases refine exact lift refine exact


pseudoMetricSpacePi

the formula let refine simp refine lift refine simpa


obtain simp rw letI inhabit refine intro replace rw exact ext simp


have nhds_basis_uniformity rcases rcases exact


have ext fin_cases have ext fin_cases grind


set have apply use refine intro fin_cases try all_goals


rw intro by_cases simp_rw rw exact rw simp rcases rw specialize simp rcases apply intro have refine apply exact


intro wlog specialize rwa simp_rw rw simp and_true, rw by_cases calc rw rw gcongr simp exact simp rw calc rw gcongr exact


Bornology.IsBounded.cthickening

have apply exact cthickening_subset_thickening


refine rw have replace obtain calc edist


by_cases exact obtain simp rw positivity


obtain refine rw rintro rw rw obtain obtain refine calc edist


apply exact unfold intro simp apply intro rcases apply rw exact


by_cases rw apply obtain rw apply exact rw exact


rcases simp refine obtain have have rw exact exact


rcases simp rw refine obtain isClosed_closure.exists_infDist_eq_dist replace exact


obtain simp obtain simp intro simp_rw exact


obtain simp intro simp_rw rintro exact infEDist_le_edist_add_infEDist.trans_lt


apply use exact rintro refine rw calc thickening intro have obtain let have apply apply exact refine rw calc thickening


apply rcases rw apply simpa rw apply simpa


cases inl inr rw push intro cases inl rw simp inr use simp


cases inl inr rw simp intro cases inl use simp inr


let have suffices obtain choose refine rw intro obtain rw exact


let have apply intro obtain refine obtain exact


classical let dist_self dist_comm y obtain simp simp dist_triangle eq_of_dist_eq_zero refine rw refine convert refine simp by_contra change simp_all refine rw obtain refine specialize by_contra change simp_all


splits rw refine have intro rw simpa haveI suffices intro induction h simp subst set have rcases simp rsuffices grw set have have obtain have intro rw intro rw forall_iff_forall_mem, exact have exact have have have refine cases zero succ rw have refine convert rw exact rcases simp rw have have refine rw have rw sum_take_add_sum_drop, convert rwa


classical separates satisfies pseudometric to obtain rcases rcases hB.subbasis_with_rel hB.tendsto_smallSets.eventually exact set have intro refine simp split_ifs simp simpa have have letI have have intro dsimp split_ifs rw exact push_neg simp have refine by_cases refine rw simp rintro refine exact exact rw refine refine rwa refine rw contrapose refine rwa div_le_iff₀


rcases let haveI letI haveI rsuffices exact have disjoint_compl_right.mono_right obtain rcases refine exact have intro rcases exact choose have set have refine such we refine have have refine exact refine rcases exacts includes refine rintro rcases set refine replace contrapose rw exact


suffices rcases refine refine suffices apply simpa refine simp by_cases refine simpa simp rcases suffices rcases exact have refine have inter_mem_inf rcases rcases refine exact refine exact exact


rw replace rintro have exact refine have rw exact


apply intro rcases use by_cases replace use simp obtain lift lift rcases rcases refine rwa


classical let have have let have obtain isIrreducible_iff_sUnion_isClosed.mp rw exact have rw refine rw refine rw rintro by_cases exact rw rcases refine simp refine rintro exact exact refine exact


refine simp rw rw congr rw refine intro rw simp_rw intro simp


have rw exact refine simp rw congr nth_rw rw simp


simp have rw refine have have rw refine refine simp


set intro dsimp have rw exact refine rw apply rw exact rw change rw


ext exact simp simp_rw e.lift_openEmbedding_symm, refine rw exact


letI rw refine rintro induction basic univ inter sUnion let exact


let apply intro replace refine rcases exact exact


refine rcases filter_upwards rcases exact rwa simpa


cases refine induction basic univ inter sUnion rintro exacts


letI simp_rw constructor rintro exact rintro exact


rcases simp have simp by_cases simp constructor intro have rw rcases exact intro refine intro rcases use simp_all rintro use simp_all suffices contrapose simp_all intro rcases rcases apply calc a


refine comap_coe_nhdsLT_eq_atTop_iff rw rfl


rcases exact obtain exists_countable_of_generateFrom have choose refine apply apply simp grind rw apply grind


refine rintro apply apply rw exact apply rw exact simp intro let let have have ext grind have have have choose have choose refine finite_range rw simp


tendstoIccClassNhdsPi

constructor conv simp intro have refine filter_upwards


let refine refine simp refine by_cases rcases rcases exact exact by_cases rcases rcases exact exact


rcases use simpa rcases rcases have exact refine exact


obtain obtain rcases obtain exact exact obtain exact


constructor intro rcases rcases exact rintro apply


refine refine simp exact rintro rw let exact rw let exact


nontriviality let have choose have suffices have rcases exact refine refine exact intro suffices simp let have intro apply simpa choose have rcases refine refine by_contra exact refine refine by_contra exact refine suffices rw exact exact


which family nontriviality have let have hx.2 choose have apply intro calc f have have rintro wlog exact have apply rintro simp exact apply rintro simpa exact


obtain obtain have refine simp obtain exact rw exact rw exact


haveI suffices rw by_contra rw rcases hs.elim_directed_family_closed exact


refine obtain refine rewrite convert haveI obtain obtain exact hts


rcases have obtain refine by_cases exacts


rcases simp_rw exact rw intro obtain hK.exists_sSup_image_eq_and_ge rw have refine refine exact have rintro exact obtain refine rw exact


constructor rcases set refine exact exact rintro by_contra wlog refine simpa cases inl specialize simp inr rcases simpa


apply exact rcases rw have simp exact rw exact


refine obtain obtain obtain rcases exact obtain exact


suffices intro by_contra suffices simp_all rw grind


rcases refine exact exact exact simp simp


apply rw exact intro rcases use simpa exact


IsLocalMaxOn.closure

rcases refine rintro refine rwa exact exact


ext constructor exact rcases exact exact


rw induction empty simp by_contra rw obtain exact cons simp set


convert ext simp constructor obtain use rw simp diff_self_inter, exact obtain lift use ext simp


constructor let use rw aesop obtain exact form


simp constructor exact a image_subset_iff.mp simp_rw intro rw exact


rcases apply_rules have by_cases refine mem_of_subset_of_mem mem_Icc_Ico_Ioc_Ioo_of_subset_of_subset simp refine rcases exact exact iterate rcases exact exact iterate exact


intro rcases simp exists_apply_eq_apply,


let replace have let have have rcases exact exfalso rcases exact


rcases simp_all set have have set have obtain refine rcases have apply have exact apply exact obtain apply exact suffices apply obtain obtain have refine rcases exact exact have order


have by_contra suffices apply rintro have have rw exact apply have exact


simp not_exists, refine simp_rw exact obtain exact


intro by_contra have by_cases obtain have simp_all by_cases obtain rw exact replace obtain have simp_all


intro let let have have have have have hf_i.injOn.injective exact have have replace replace exact replace have have replace replace exact


rcases intro rcases exact rcases rcases exact


rintro replace haveI refine exact mem_of_superset hf hy.2


Dense.ciSup'

by_cases refine simpa suffices contrapose grind


simp refine by_contra have set have have let have have have have filter_upwards have have have have exact


obtain replace have have choose refine hvx.comp rw rw


Order.IsNormal.continuous

rw refine rw obtain exact obtain exact have have rw exact


Topology.IsLawson.isTopologicalBasis

have lawsonBasis rw simp_rw aesop rw convert rw apply letI exact letI exact


have refine refine simp apply rcases simp by_cases simp have exact


have rw simp rw simp apply rintro rcases simp obtain obtain have simpa filter_upwards rcases simpa by_cases simpa apply filter_upwards


obtain apply apply rintro obtain have simpa filter_upwards rcases simpa by_cases simpa apply filter_upwards


rcases simp apply rintro obtain simpa filter_upwards apply filter_upwards


letI haveI rcases simpa haveI rw refine simp exact simp intro exact


letI haveI rcases rw exact rw refine simp intro exact


letI haveI rcases simpa obtain calc rightLim


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


is topology. let suffices have intro by_cases simp simpa apply simp have simp not_le, rcases obtain refine contrapose apply intro exact choose apply simp intro wlog have exact have by_contra have simp rw exact


rw constructor rintro rcases exact rintro exact


replace induction basic univ inter sUnion


Topology.IsLower.isTopologicalBasis

convert simp_rw ext constructor rintro refine simp rintro haveI rw choose exact


by_cases simp refine intro apply convert constructor intro use constructor apply use rw intro have by_contra apply rw exact use rw apply intro simp intro obtain subst simp_all intro rw intro simp rw exact


have apply rcases exact simp apply have filter_upwards rcases exact simp apply have filter_upwards exact


nontriviality let have choose let suffices have intro have rwa exact apply rintro rw exact simp intro wlog apply have order simp rintro rw have have rw exact


apply rintro dsimp contrapose refine filter_upwards exact rcases have simp filter_upwards exact


apply refine simp rintro simp intro exact


refine obtain simpa filter_upwards exact rcases filter_upwards exact


refine rcases filter_upwards exact obtain simpa filter_upwards exact


rcases refine obtain simpa filter_upwards refine exact


have refine filter_upwards hb.trans_le rcases rw filter_upwards rintro exact


have refine filter_upwards rcases have filter_upwards rintro exact


constructor intro rw exact simp rintro refine exact


have nonempty_Icc.2 obtain obtain by_cases by_cases have le_antisymm rcases refine simp refine exacts refine exacts


have obtain exists_Ioo_extr_on_Icc exact


have obtain exists_uIoo_isExtrOn_uIcc exact


refine rw exact image_inter_nonempty_iff.mp refine by_contra let have rw obtain simp exact


constructor intro rcases exact apply use rw exact rintro exact exact


constructor intro simp_rw exact intro rw apply apply apply rw


classical rcases infer_instance and second-countability. for obtain exists_countable_generateFrom_Ioi_Iio obtain let let suffices refine have have rw exact apply apply grind generated half-infinite let have rw apply simp rintro induction top apply exact coe rw intro induction top rcases refine have have simp exact simp apply simp obtain refine apply simpa apply exact coe simp obtain h_basis.isOpen_iff.1 refine intro induction top coe simp apply simpa apply apply exact intro apply grind apply exact intro apply grind induction top apply exact coe rw intro induction top coe simp obtain h_basis.isOpen_iff.1 refine intro induction top coe simp apply simpa apply apply simp apply apply exact intro apply grind apply exact intro apply grind


obtain simpa rw intro filter_upwards simp


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


classical rw suffices rw apply rintro simp exact


rcases have rcases choose h01 have refine hfp, rcases exact


set have have rw exact have rw exact classical letI rw sub_sub_cancel] refine convert rwa


rcases use filter_upwards simp apply intro exact


obtain use refine intro simp have rw rwa intro exact


ext simp split_ifs have norm_num refine norm_num refine simp ring exfalso linarith


have have simp refine change exact change exact rintro simp


change have rw intro have have rw rcases rw exact rw


constructor intro by_cases exact have rw rw exact


constructor exact intro have rw have rintro simp exact rw exact


Perfect.splitting

obtain obtain have rw rcases exact obtain use constructor refine rw exact constructor refine rw exact apply


intro rw specialize trans simp apply exact exact obtain use simp apply simp apply rw exact


obtain let let let have simp apply exact exact refine refine exact rw intro have intro obtain have apply rintro by_cases exact exact exact have apply exact by_contra exact rw


rcases refine constructor rw by_contra rw rw contradiction rw exact


ContinuousOn.if'

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


ContinuousOn.if

apply rintro simp apply exact rintro simp apply rcases rw apply exact exact


intro convert symm rw exact intro rw exact rw convert rw exact intro rw exact rw convert rw exact


simp have have let let have apply change exact intro have exact have have obtain refine let suffices filter_upwards


constructor intro by_contra obtain exact ltz.not_ge exact


refine suffices simpa exact rw simp grind


intro by_cases obtain filter_upwards calc y exact


LowerSemicontinuousWithinAt.add'

intro obtain mem_nhds_prod_iff'.1 by_cases obtain by_cases obtain filter_upwards have by_cases simpa simpa have by_cases simpa simpa have calc y simp filter_upwards have by_cases simpa simpa have calc y simp by_cases obtain filter_upwards have by_cases simpa simpa have calc y simp apply intro have calc y


classical induction empty insert simp exact


refine rintro intro simp by_cases rcases by_cases rcases filter_upwards rcases exact exact filter_upwards by_cases rcases filter_upwards apply exact apply intro have rw exact


simp_rw rw refine gcongr exact intro filter_upwards exact refine simp


refine obtain choose obtain hK.subseq_of_frequently_in refine filter_upwards exact specialize exact


by_contra obtain suffices apply filter_upwards exact apply filter_upwards simp exact


simp_rw rcases let have have ext simp have simp_rw rcases use rw choose set have use refine by_contra rcases obtain have simpa suffices exact


simp_rw refine rintro obtain exact obtain obtain exact


refine rcases wlog refine obtain have exact


refine rcases wlog exact obtain have exact


lift induction rename_i rcases rcases exact rsuffices exact refine refine lift exact


refine filter_upwards rcases exact rw exact


rw refine specialize rw exact rw refine exact exact


classical induction empty insert rw exact


rw constructor intro rw rintro change have have rw exact


refine contrapose have hK.disjoint_nhdsSet_right.2 simpa


have have apply rw exact have this.mono rcases exact rw


classical induction empty refine simpa insert simp simp have rcases rcases refine intro rcases simp simp intro rcases simp simp simp


let refine simp by_cases rcases exact exact


NormalSpace.instCompletelyRegularSpace

rw intro have have rw intro exact let let have have have exact


letI rw intro simp_rw obtain simp choose replace clear choose use constructorm* solve_by_elim simpa simp conv intro specialize exists


rw intro apply rw simp_rw intro obtain conv rw refine rw simp


refine choose obtain let have simpa rw obtain have have refine simp refine contrapose simpa


choose choose compact_exists_isClopen_in_isOpen obtain isCompact_univ.elim_finite_subcover refine obtain exact


classical obtain obtain simp let refine exact exact obtain have exact exact


obtain have refine simpa choose have choose refine convert exact


obtain rcases rw rw exact obtain choose apply rw exact have apply rw refine obtain refine rw use constructor rw exact refine simp rw exact


refine simp_rw refine rcases exact exact


have rcases rcases exact suffices refine exact rw exact


constructor rintro exact exact exact exact


constructor rintro rcases replace exact let exact


intro have exact tendsto_nhds_unique_of_eventuallyEq


have rw refine disjoint_compl_right.mono_left rw refine exact


constructor obtain rw filter_upwards intro simp by_contra rw have simp obtain exact


constructor apply by_contra obtain have have simp_all simp exact


constructor intro by_contra obtain exact intro exact


have rw exact choose normal_separation have by_contra rw have hd.inter_open_nonempty ht.mono rw exact have rw apply rw intro exact


constructor rintro choose obtain rcases choose exact disjoint_compl_right⟩ choose exact


refine obtain let have lift haveI obtain have refine let have have have refine have rw apply rw apply have have rw rw apply use


choose compact_exists_isClopen_in_isOpen have mem_iUnion.mpr choose exact


induction of_equiv obtain refine simp simpa h_empty let have have rw exact let have have rw simpa obtain exists_clopen_of_closed_subset_open have let have have rw refine exact obtain let have have simp exact let refine all_goals intro rw by_cases by_cases have obtain exact obtain have obtain exact rw rintro simp simpa simpa simpa


refine obtain rw rw induction basic univ inter sUnion obtain grw exact


apply rw simp intro by_contra rw obtain exact


refine simp refine rwa subset_compl_iff_disjoint_left] rwa subset_compl_iff_disjoint_right]


refine let have specialize have rw intro exact obtain normal_separation rw obtain obtain rw rw refine intro exact intro exact rw intro exact


apply refine have rw intro rcases obtain of so have rw obtain refine exact exact rwa have rw have by_cases suffices apply exact iInter_subset have suffices refine exact


refine rw have rw obtain have obtain set have exact rw refine exact


constructor rintro have have rcases simp refine simp_all refine open_lemma open_lemma cover_lemma rw rintro suffices intro have by_contra exact exact rintro exact


refine by_cases exact obtain simpa h rcases exact


IsSeqCompact.totallyBounded

intro unfold contrapose obtain simp simpa refine obtain exact


intro apply replace rw hf.closure_eq_preimage_closure_image,


refine by_cases aesop obtain rw aesop refine rintro simpa


classical rw refine refine intro by_cases simpa simp dsimp exact aesop obtain have rw exact refine simp_rw


classical obtain refine exact exact grind


choose refine refine simp aesop simpa grind


suffices obtain cases refine simp obtain choose let have have refine rw ext simp_rw refine rw obtain simp use


rw let have ext simp have have obtain obtain simp refine rw exact


rcases rw choose choose rcases by_cases exact have rcases choose have rcases inter_nonempty_iff_exists_left.mp exfalso


constructor rintro rcases refine cases dsimp subst exact refine rintro exact intro rcases exact


constructor intro refine rw simp_rw rfl intro rw intro rcases rcases exact


rw refine introv obtain refine rw rfl obtain refine simp change exact


refine let by_cases obtain rw obtain refine simp_rw grw grind simp_rw replace obtain rcases rw obtain refine insert_subset rw rintro rw obtain obtain exact obtain cases


simp_rw rintro exact obtain obtain exact


rw refine let exact vietoris.specializes_of_subset_closure


rw intro rw obtain hS.elim_finite_subcover classical refine simp_rw exact


apply intro apply dsimp set change refine rw intro apply intro rw apply rw


subst constructor rintro rw simp rintro refine rw exact rw simp rw simp


TopCat.stalkToFiber

refine colimit.desc ι naturality exact aesop


constructor as on intro obtain rcases use simp some we constructor intro set obtain obtain have convert symm convert obtain refine convert simp


let have lift fapply change refine apply exact simp exact


fapply apply dsimp ext dsimp simp fork_π_app_walkingParallelPair_zero,


TopCat.Sheaf.interUnionPullbackConeLift

let have ext rw constructor rintro exacts rintro exacts refine naturality rintro exacts rintro let have clear_value subst rcases dsimp simp rw exact


TopCat.Sheaf.isLimitPullbackCone

let have ext rw constructor rintro exacts rintro exacts apply intro use refine apply apply intro rw apply rintro erw convert apply erw convert apply all_goals dsimp op_comp, simp_rw congr simp_rw convert apply convert apply


apply refine intro exact intro rw obtain exact


instRepresentablyFlatOpensCarrierMap

constructor intro refine constructor intro exact exact exact


simp_rw refine exact specialize h convert rfl exact


have obtain refine intro rw exact intro convert rw rw exact


let have intro simp_rw rfl obtain trans apply intro rfl symm apply intro rw


have suffices convert rw apply intro rw exact


classical fapply exact refine rw constructor exact exact rintro any_goals any_goals


apply intro obtain use fconstructor exact exact


apply intro rcases rcases have dsimp have dsimp rcases use refine change exact change exact intro specialize specialize refine rw


TopCat.Presheaf.stalkSpecializes

refine exact colimit.ι intro dsimp rw let let exact


obtain revert induction op obtain intro exact


intro obtain obtain rw obtain simp simpa


choose apply intro simp exact intro rw imply is


conv enter rw intro choose have intro simp exact suffices obtain use apply intro rw intro apply intro apply dsimp rw simp_rw rfl


rw split_ifs have exact push_neg refine simpa


have simp intro rcases exact have rcases classical refine intro rcases refine by_cases rcases use rwa use rw exact rintro rwa rw exact exact intro rw rw refine exact exact


haveI have rcases suffices intro rcases exact


set simp have apply have apply intro exact exact have intro have rw apply have rw rw exact obtain obtain by_contra exact exact obtain classical refine intro rcases refine by_cases rcases use rwa use rw apply rw exact rintro rw exact rw exact intro rw by_cases rw simp exact apply intro exact intro rw exact intro rw rw refine exact exact simp exact


haveI have rcases suffices intro exact intro by_contra rcases exact


refine simp forall_apply_eq_imp_iff₂] exact


obtain obtain refine obtain obtain exact refine simp exact simp convert_to simp refine simp_rw rintro have exact


refine use intro exact intro obtain exact


rw constructor intro exact intro rw obtain use ext exact


have have norm_num1 rcases simp replace have have have have refine rwa rcases refine refine simpa refine have rcases calc g rw rcases simp calc dist calc g rw


between choose set have have have intro induction zero succ ihn rw refine rwa have intro calc dist have have have refine refine rw refine refine rw refine ring rw exact


rcases refine suffices simpa refine simpa ext have simp


inhabit obtain obtain have have rcases have use simp set have have have simp ring such in obtain rcases rcases exact function whenever have refine rw rintro exact exact rcases exists_bounded_mem_Icc_of_closed_of_le replace intro simp refine have rcases refine calc exact rcases refine rcases simp calc g rw minor choose rcases exact have refine rw rintro exact exact rcases exists_bounded_mem_Icc_of_closed_of_le replace intro simp refine have rcases refine calc exact rcases rcases rcases refine calc f have calc a rcases exact refine simp


cases rcases exact rcases refine rcases exact


have let continuous_toFun map_bounded isBounded_range_iff.1 let have have constructor rintro lift change rw rcases exact have rcases let have refine rcases convert exact ext exact


let let intro have simp apply apply exact


refine le_antisymm simp_rw refine intro rcases let rcases have rintro rw rcases exact hVU exact


rcases simp constructor exact set set comap have have hS.inducing_uniformFun_iff_pi.mpr have have have rwa


rw simp_rw nhds_induced, congrm have rw rfl


suffices rw exact rw exact exact exact exact


suffices induction zero succ rcases refine rw have exact


let have mem_nhds_iff.mp show rw exact exact choose exact isOpen_iUnion simp iUnion_subset


intro rcases have rw exact apply rintro exact


refine rcases refine refine rw apply apply exact


rw constructor obtain exact obtain exact


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


have rw rcases exact obtain extraction_forall_of_eventually exact


constructor rw intro obtain use intro convert exact


refine exact rcases rcases refine exacts


set intro rw obtain obtain rcases refine gcongr obtain rcases rcases refine rcases rwa rcases exact


rcases rcases let choose refine exact haveI exact filter_upwards simp_rw set exact


constructor exact intro contrapose set have have have refine rcases rcases have rcases exact


intro obtain refine rw intro rw rcases exacts


rw intro have classical refine simp iUnion_iUnion_eq_right, exact


rcases obtain choose refine refine simp rintro exact intro simp rcases rcases rcases rcases hsd.inter_open_nonempty refine exact


obtain replace choose have choose refine countable_iUnion rw intro obtain obtain specialize rw obtain refine apply exact exact


apply intro simp refine intro obtain exact intro obtain exact intro simp grw exact


obtain lift classical refine rw refine obtain exact


rw intro rw obtain rw refine rintro obtain exact


constructor rw exact simp_rw filter_upwards simpa


simp_rw intro obtain refine simp constructor grw grw


refine rw intro obtain refine simp constructor grw grw


simp_rw intro obtain refine obtain exact


open simp_rw intro have let refine obtain obtain dsimp filter_upwards isOpen_inter_nonempty_of_isOpen u grw


suffices refine rw intro obtain mem_of_mem_nhds obtain exact


have obtain rw exact choose rcases refine rcases exact


have rw rcases rcases refine simp rintro rw exact


rw constructor intro rw intro rcases rcases set have inter_mem_nhdsWithin f.continuousAt have have use refine exact intro rcases filter_upwards


set set set have have have have have h_cover subset_univ simp_rw rfl


set set have have have refine simp_rw simp_rw rfl


classical intro rcases have have refine refine exact have set refine rwa


let have delta simp have uniformity_lift_le_swap have simp exact exact


apply exact intro rcases filter_upwards filter_upwards exact hVU


obtain constructor rintro exact rintro rw exact


rw constructor rintro use exact rintro exact


refine simp have refine filter_upwards exact simp_rw intro simp_rw obtain refine filter_upwards refine simp exact


constructor rcases refine exact rcases filter_upwards


EquicontinuousWithinAt.closure'

intro rcases filter_upwards rw change refine exact


UniformEquicontinuousOn.closure'

intro rcases filter_upwards rintro rw change refine exact exact


intro rcases filter_upwards rintro exact


rw intro rcases rw have eventually_mem_nhdsWithin.and rcases filter_upwards exact


obtain choose exists_mem_nhds_ball_subset_of_mem_nhds obtain apply rintro obtain apply refine exacts


apply exact intro exact intro refine rcases exact exact rcases intro obtain mem_nhdsWithin_prod_iff.1 refine have have exact


refine choose obtain replace rw refine specialize simp obtain exact


simp constructor rintro obtain exact rintro obtain exact


CompleteSpace.iInf

nontriviality rcases have simp_rw const, simp_rw have iInf_mono refine exact


Real.instCompleteSpace

apply intro let refine rcases have simp exact


rcases apply intro rw rcases suffices apply intro rcases obtain by_contra exact exact


rw constructor rintro rw obtain refine rintro exact


IsUltraUniformity.separationQuotient

have rw apply exact rintro constructor rintro simp rintro have rw exact exact


refine obtain obtain rcases have have have have exact


simp_rw intro obtain obtain filter_upwards exact


intro rcases have apply simp intro exact


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


UniformCauchySeqOn.prodMap

intro rw obtain simp_rw rw apply intro exact


rw intro rw obtain have have have obtain filter_upwards


ext refine exact exact refine rcases exact exact


ext simp_rw refine rcases refine rcases exact


have have rcases rcases exact refine rcases exact


simp refine simp intro obtain refine simp intro obtain exact


constructor replace change rw congr rw rfl


UniformOnFun.instCompleteSpace

rcases infer_instance refine have have choose use simp_rw intro rcases filter_upwards refine filter_upwards


set set have refine simpa refine rw exact rw exact simp_rw exact


set have rcases refine simpa refine rw exact simp_rw exact


rw lift lift rw have h.of_tendsto_comp apply rwa


classical obtain let have rw refine have apply rw refine


obtain rwa rcases refine have refine refine rcases exact


refine simp_rw intro rcases use simp_rw exact


have have have have let replace simpa refine rw exact


obtain obtain have have calc ds replace have refine refine rw exact


ext rcases simp rcases lift simp_rw simp


obtain have simp_rw have refine obtain exact hsub half_lt_self


induction zero rw exact succ simp rw exacts


induction zero succ simp have norm_num exact


induction zero simp refine grw rw positivity succ simp refine exacts


obtain refine continuous_iff_continuousAt.2 simp induction zero filter_upwards rw exact succ by_cases filter_upwards rw c.right.lim_of_mem_C refine rw gcongr replace filter_upwards ihn replace replace simp c.left.left.lim_of_notMem_U grw set calc


let set closed_C open_U subset hP rintro rcases exact exact


obtain exists_compact_closed_between let set closed_C open_U subset hP rintro rcases have refine exact c.lim_of_notMem_U


obtain use refine intro simp exact intro simp exact intro simpa


obtain exists_compact_closed_between rcases exists_continuous_zero_one_of_isCompact have refine simpa apply simp apply contrapose simp exact have simp


rcases obtain exists_compact_closed_between have apply rw exact choose obtain let have intro have have exact simp have have refine apply simpa apply apply intro obtain have have apply exact simpa exact exact apply exact


rw obtain rw have let set closed_C open_U subset hP intro obtain simp_rw obtain refine exact use simp refine apply rw apply exact intro apply exact


obtain obtain exists_tsupport_one_of_isOpen_isClosed have exact


Pretrivialization.symmₗ

refine by_cases exact congr_arg rw exact


have have have have refine mfld_set_tac mfld_set_tac intro ext dsimp


rw rw refine apply have apply apply exact have apply apply exact filter_upwards simp


instIsContinuousRiemannianBundleTrivial

refine rw intro rw refine convert ext simp


rcases have simp exact simp have simp exact


is obtain have let let obtain have have apply exact have apply simpa exact rcases let have have simp exact have rw apply filter_upwards have apply let suffices le_of_sq_le_sq simp have rw have convert rw rfl simp have rw simp rw have calc g grw simp have rw grw gcongr rw positivity exact


refine filter_upwards have ext have simp coe_id', convert rw rfl have grw gcongr linarith


is obtain have let let obtain have have apply exact have apply simpa exact rcases let have have simp exact have rw apply filter_upwards have apply let suffices le_of_sq_le_sq simp have rw have convert rw rfl simp have rw simp rw calc g grw simp congr rw simp rfl gcongr rw positivity


refine filter_upwards have ext have simp coe_id', convert rw rfl have simp grw gcongr linarith