revert induction zero succ intro let have obtain obtain refine by_cases rw exact simp obtain exact


obtain intro let have obtain refine simpa


rw intro by_cases rw exact by_cases exact have have have obtain obtain obtain rw specialize ht₂ obtain refine rw grw sub_eq_add_neg, eLpNorm_add_le have refine rw exact have refine rw exact have specialize have have eLpNorm_indicator_sub_le_of_dist_bdd dist refine rw refine rw refine hdivp rw exact exact positivity have rw simp rw rw gcongr


intro rw obtain let have obtain refine by_cases exact exact


refine obtain exact tendsto_Lp_finite_of_tendsto_ae let hms'⟩


have by_cases rw exact intro obtain refine by_cases rw simp calc eLpNorm eLpNorm eLpNorm refine le_trans hp) congr change rw rw refine rw rintro rw exact refine rw rw have filter_upwards simp_rw exact refine rw grw gcongr rwa gcongr rw mul_div_cancel₀


set refine obtain have intro refine filter_upwards by_cases rw rwa rw rwa refine rw grw


intro obtain refine refine exact filter_upwards by_cases simpa simp


cases refine by_cases choose set refine rw exact refine rw obtain exact exact


refine obtain refine calc eLpNorm eLpNorm refine le_trans hp) rw split_ifs rw simpa rw simpa have filter_upwards simp_rw exact refine simp_rw exact


set have have refine obtain refine filter_upwards by_cases rw rwa rw rwa


MeasureTheory.UniformIntegrable.spec'

obtain obtain obtain by_contra choose lift have intro calc rw simp_rw refine refine le_eLpNorm_of_bddBelow rwa specialize rw mul_assoc, refine rfl rw exact exact


MeasureTheory.UniformIntegrable.spec

set have have obtain refine filter_upwards by_cases rw rwa rw rwa


obtain refine exact obtain refine simp_rw refine have obtain simp simp_rw rw refine simpa obtain simp_rw refine obtain simp simp_rw rw refine simpa


refine exact obtain exact eLpNorm_le_of_tendstoInMeasure


rcases rw exact suffices have simp_rw refine exact refine exact


set set set have refine exact rintro replace change refine hI have rw rw apply rw div_le_iff₀ refine exact exact replace haveI have change rw simp_rw rw hG_card, exact


refine rw conv simp conv have apply rw simp


suffices intro rw refine le_of_tendsto_of_tendsto filter_upwards rw refine simpa


contrapose refine dsimp refine rw rintro refine rw


refine rw refine rintro rw refine intro ext rw simp


ext rw apply exact intro ext have apply use simp


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


obtain rw have apply convert exact infer_instance


have rw ofReal_pow norm_num rwa obtain obtain refine rw simp_rw rw refine


constructor rintro change rw map_mul_left_eq_self


constructor rintro change rw map_mul_right_eq_self


refine rw obtain conv_rhs rw congr ext simp


obtain obtain filter_upwards calc μ gcongr exact


refine contrapose rw rw obtain compact_covered_by_mul_left_translates calc μ


rw obtain compact_covered_by_mul_left_translates exact


find infinitely same obtain have have choose set have induction zero succ simp_rw apply have induction zero succ simp_rw apply have induction zero succ calc μ simp_rw exact have simp_rw apply exact simp apply exact


apply conv_rhs simp intro apply rw exact


let obtain exists_continuous_nonneg_pos have ne_of_gt apply have refine exact have rw exact have refine rw apply calc rw rw rw rw


borelize have have let symm calc modularCharacterFun rw simp


suffices convert apply apply infer_instance


refine rw have suffices simpa this have simp_rw inv_preimage,


wlog filter_upwards lt_of_le_of_lt refine intro simp apply have rw simp_rw indicator_mul_right rw finiteness


wlog rcases rw wlog rcases rw have have rw rw


obtain obtain obtain obtain refine haveI refine filter_upwards intro exact


obtain obtain obtain refine rw smul_eq_mul, haveI refine integral_mono_of_nonneg filter_upwards intro rw exact


have rw refine have conv simp rw refine refine exact


by_cases rw rw exact refine mem_segment_iff_div.mpr calc


refine replace rwa exact haveI refine refine refine simp exact exact rwa refine exact


obtain simpa have rw rw measure_diff_null refine rintro dsimp rwa simp_rw exact


obtain simp obtain have rw have simp_rw rw measure_diff_null refine rintro dsimp rw exact simp_rw exact


have filter_upwards contrapose simp have filter_upwards rw simp simp_rw apply have apply exact rw apply exact exact have have simp refine filter_upwards have rw intro simp have simp apply simp_rw have intro have simp rw refine apply change simp dsimp have simp exact


let let let have have rcases rcases apply grind


let have rw congr apply filter_upwards rw congr apply rw rw have rw congr apply filter_upwards rw congr apply simp rw rw exact


by_cases rw have rw refine simp intro simp exact rw rw simp_rw have refine dsimp rw rw


refine intro calc refine refine rw exact fun_prop filter_upwards exact apply all_goals


simp_rw hasFiniteIntegral_iff_ofReal rw rw simp exact


let have filter_upwards simp have suffices simp_rw exact have filter_upwards simp exact rw simp_rw rw have swap rw finiteness refine h_cont.tendsto.comp refine exact filter_upwards refine simp exact filter_upwards refine simp exact


suffices suffices convert refine filter_upwards filter_upwards


let let have intro unfold rw exact filter_upwards simp have unfold rw exact filter_upwards simp have simp_rw refine rwa have filter_upwards refine simp have filter_upwards refine simp have rotate_left exact exact filter_upwards have unfold ext rw abel simp have unfold rw abel simp rw refine exact


let let suffices filter_upwards convert simp simp refine convert rw rw filter_upwards simp filter_upwards simp


have simp_rw simp rw exact exact rw exact


by_cases simp have simp_rw have have rw setToFun_congr_measure_of_add_left refine rw rw


have simp refine lift have have refine exacts refine obtain refine simpa rw rw refine rw exact


by_cases simp rcases rw simp_rw have mul_one have rw exact


rcases simpa have calc ε ae_restrict_mem₀


have refine filter_upwards rw have refine filter_upwards rw have refine filter_upwards rw rw exact


have have rw apply exact exact exact rw congr rw simp


by_cases simp borelize by_cases swap have rw haveI let have have have have integral_trim_simpleFunc have refine exact have simp_rw refine exact exact


by_cases suffices rw norm_cast have rw exact have filter_upwards rwa filter_upwards rwa by_cases swap have by_contra exact rw exact simp simp haveI rw have rw refine filter_upwards rw simp_rw rw simp grw rwa exact


apply intro rw smul_assoc, congr rw intro simp integral_add exact intro convert exact rw


by_cases exact by_cases have rwa simp rcases simp


by_cases by_cases rw rwa refine intro rw simp_rw simp rw rfl exact refine simpa intro change simp_rw rw exact exact have continuous_integral have have continuous_integral.comp convert simp exact exact intro rw apply filter_upwards rcases simp rw simpa


let calc congr apply filter_upwards rw apply filter_upwards rw


classical refine intro simp rcases exacts dsimp rw measureReal_restrict_apply exact


have simp rw refine rw rintro by_cases rw apply simp


rw apply rw intro by_cases positivity suffices rw refine simp exact


simp apply simp intro by_cases obtain simp simp gcongr exact exact suffices have simp rw refine simp_all


have have filter_upwards convert rw refine rw


rw filter_upwards intro rw change rw simp


have filter_upwards rw conv_lhs rw have filter_upwards rw conv_lhs rw change apply filter_upwards rw exact exact exact


refine simp exact refine intro norm_cast exact


classical induction empty insert simp rw rw simp exact exact


simp_rw have refine grind have apply rw rw intro rw apply simp rcases exact congr convert rw norm_cast


refine have have set have have rw set refine lift have tendsto_measure_iUnion_atTop filter_upwards rw refine rw exacts


refine have rcases suffices convert rw exact rw apply refine exact rw exact


by_cases rw contrapose exact have refine rw filter_upwards rw exact rw exact


let have have have rw union_comm] apply rw apply rw filter_upwards


have by_cases rw let calc apply filter_upwards rw integral_congr_ae


let have calc apply filter_upwards change simp intro by_cases simp simp intro exact have rw


by_cases have rw let calc apply filter_upwards rw apply apply exact


by_cases apply have filter_upwards rw exact have filter_upwards rwa rw have apply contrapose simp rcases have simp positivity


have rw have integral_mono_ae have rw exact


rw refine rwa rwa exact filter_upwards rwa


by_cases simp let have have apply exact apply rw apply intro apply by_cases simpa apply simpa intro simpa


refine have simp_rw have rw have simp_rw convert


ext1 refine refine refine refine refine rw


refine simp have ext1 by_cases simp simp rw exact


rw intro rcases rcases apply filter_upwards filter_upwards rw filter_upwards exact exact filter_upwards


have refine simpa intro apply obtain simpa obtain hk.mem_uniformity_of_prod simp_rw have intro obtain have have exact rcases refine by_cases exact simp have apply borelize apply apply apply apply apply gcongr apply filter_upwards calc congr refine simp refine simp apply exact filter_upwards by_cases dsimp specialize calc simp positivity


induction let by_cases refine simp exact by_cases refine classical simp simp have classical simpa have have simpa obtain refine simp grw suffices classical simpa calc simp_rw rw simpa rcases rcases refine simp rw convert conv_lhs abel


rcases have choose refine rw exact refine exact calc rw refine rw simp_rw intro


have convert simp lift obtain have rcases have have have apply filter_upwards simp refine refine simp convert rw calc apply simpa rw apply exact apply apply


induction classical by_cases exact have have obtain hs.exists_isClosed_lt_add refine simp grw suffices simpa calc simp_rw rw simpa h₂ have rwa rcases rcases refine simp rw convert conv_lhs abel


lift rw have rcases have refine simpa refine refine exact rw rw convert simp rw simpa apply exact apply exact


rcases refine exact exact convert simp simpa simp_rw rw simpa


rcases simp have have have apply have simp_rw simp have rwa have simp_rw simp have rwa


rcases simp have have have apply have simp_rw simp have rwa have simp_rw simp have rwa exact exact


calc circleAverage rw match_scalars field unfold congr simp field_simp


intro apply intro by_contra obtain have simp rwa


by_cases simp apply rw exact codiscreteWithin.mono


by_cases simp refine simp refine have simpa h.aestronglyMeasurable simp


constructor intro simp rw replace refine set have suffices filter_upwards simp_all refine refine set suffices simp simpa this have rw refine rintro exacts


by_cases rcases exact have intro convert have simp exacts refine exact


refine refine rw rcases rw_mod_cast exact mul_nonneg rw have rw


have suffices have refine simpa have refine have refine simp rw intro rw


apply_rules rw fun_prop exact apply exact


simp_rw apply_rules exact rintro have exact


have apply_rules simp apply_rules simpa exact


obtain obtain obtain let obtain refine obtain have simp have mul_le_mul rw simpa


let have have rw rcases rw linarith simp rw rw ofNat_smul_eq_nsmul,


rw curveIntegralFun_trans_of_lt_half congr ring


and simp intro obtain rw exact rw filter_upwards have rw refine rw refine refine refine rw exact rw exact


set have rw simp have rw exact have have have simp set have have have rintro lift lift simpa set fderivWithin set have rw apply have have rintro refine rwa set have rintro refine hcontdiff.fderivWithin rwa have intro exact set set have intro simp congr have refine exact exact exact set have intro simp congr have refine exact exact exact uniqueDiffOn_Icc_zero_one suffices have simp apply rw intro simp have simpa have simpa have simp apply rw intro simp simp rw linear_combination set have rintro refine rcases lift lift apply simpa simpa simpa exact filter_upwards have rintro lift lift have refine rw refine simp have simp set have intro exact set have intro exact have rw filter_upwards simp suffices have refine rw refine lift simpa exact rwa exact exact exact fun_prop fun_prop exact exact rw apply simp


set have rw intro simp have convert dsimp rw dsimp rw simp intros apply exact rw exact intro apply have rw rintro lift lift simp refine simp fun_prop


rcases rw have have rw rintro rcases simp rcases have rw simp rw have exact


wlog specialize rw simp refine wlog specialize rw simp refine simp calc simp rw apply assumption


have eventually_countable_forall.2 have intro filter_upwards have refine exact simp refine exact filter_upwards filter_upwards calc


by_cases simp have have rw refine intro rw exact convert intro filter_upwards rfl simp_rw rw apply apply exact dsimp have convert apply simp_rw filter_upwards exact filter_upwards exact


by_cases simp rw exact have dsimp rw simp rw exact


let have funext rw rw refine intro rw exact rw exact simp_rw refine grw filter_upwards


by_cases have have have rintro apply apply exact exact have rintro rw apply apply exact exact apply refine have apply exact apply have refine filter_upwards intro rw rw exact exact exacts filter_upwards dsimp split_ifs have apply rintro have apply apply intro simp apply simp have apply apply intro simp apply simp apply rwa


have have have have have rw refine rintro dsimp have a₀ rw exact exact exact exact rw refine exact ae_imp_of_ae_restrict refine apply apply rw exact suffices have rw refine rintro have apply rintro calc exact apply have suffices apply apply apply apply rw rw exact


by_cases have intro simp_rw rw intro refine simp exact rw exact


rw rintro apply obtain obtain rw rw have obtain obtain δ have have have have simp filter_upwards exact have suffices simp exact apply exact rcases exact obtain have rw simp apply filter_upwards rintro simp have from small calc congr rw rw gcongr exact exact gcongr exact exact apply simp exact exact exact gcongr exact exact exact calc gcongr apply change apply simp exact exact exact exact exact exact


classical revert refine simp intro rw swap swap exact rw h_add congr exact simp_rw intro refine rw exact


have refine have calc simp gcongr exacts


have intro simp exact refine have rw refine simp ring


classical have have simp refine rcases by_cases simp_rw rw rw rw have rw rw have rw rw simp refine rw rw exact grind grind


refine refine rw refine simp_rw intro rwa


classical simp_rw suffices rw refine rw push_cast rw intro refine rw exact


classical simp_rw suffices rw refine rw intro refine rw exact


refine by_cases simp refine rw obtain rw convert


classical obtain simp simp_rw obtain haveI simp rw by_cases simp_rw rw swap rw congr simp rw swap rw swap simp


calc rw refine rw simp_rw refine rw ring_nf rw simp_rw


calc rw simp_rw rw simp_rw congr simp_rw volume_real_Ioo_of_le mul_one, congr refine rw rw ring rw ring


rcases let have intro rw exact apply intro obtain exact mem_iUnion.2


let have let have rw exact intro have apply filter_upwards ae_restrict_mem₀ by_cases by_contra exact exact apply rw exact


by_contra obtain rcases let have have have lt_of_le_of_lt have exact


ContinuousOn.aemeasurable

classical nontriviality have refine apply intro obtain rw exact


have refine conv rw conv refine rw apply


have have intro rw exact refine filter_upwards rw exact


refine rw grw gcongr apply simp exact exact


suffices suffices apply have have apply intro exact rcases exact have apply simpa simp exact have rcases filter_upwards rcases refine calc dist rw intro simp exact rw exact apply apply filter_upwards have exact


let have have have have apply have have apply intro rcases rw exact rwa exact


suffices let have intro have simpa have apply exact f'int.neg).mono_set refine have simpa


let have have have have apply have have apply intro rcases apply rw exact rwa exact


let let have have have rw exact convert simp rw simp simp


let have have rcases apply intro rw rpow_neg exact exact have ext1 rintro intro rw have rw refine intro rw


let have have rcases apply intro rw rpow_neg exact exact have ext1 rintro intro rw have rw rw refine simp_rw


rw let have intro apply filter_upwards exact have apply filter_upwards exact simpa


have hf.integrableOn_of_subset_isCompact have let have have have have rwa obtain exists_eq_setAverage exact


rcases exact let let obtain apply grind intro simp rw linarith simp simp intro apply have obtain have rw exact have filter_upwards ε refine exact simp refine have have hu₃ replace rw filter_upwards grind have convert simp rw simp_rw apply_fun rw convert grind


let replace replace let have have have have have intro grind have replace refine simp convert simp rw convert exact abel rw simp_rw have simp have dist rw add_right_comm, grw simp exact


wlog exact suffices rw intro suffices contrapose exact intro rw have rcases simp replace have have let have have have have have grw simp nth_rw simp field_simp rw grw rw have grw field_simp grind have have have hu₄ linarith


revert refine simp intro rw refine exact apply simp intro exact


have have rw refine rw filter_upwards rw exact


rcases simp apply intro apply apply exact have apply simp rw filter_upwards exact


norm true let have rw rw restrict_Ioc_eq_restrict_Icc] apply apply rw filter_upwards rw exact exact have simp


wlog exact rw obtain have lt_of_le_of_lt have exact


wlog specialize have rw refine simp rwa rw obtain have have have lt_of_le_of_lt have rw rw have rw have rw exact constructor apply rw filter_upwards exact have lintegral_enorm_le_liminf_of_tendsto grw rw intervalIntegral.integral_of_le convert refine rw filter_upwards exact


obtain have apply rw filter_upwards have rw have replace replace exact


by_cases simp have have simp_rw refine cases cases simp_rw abel


refine le_of_forall_pos_le_add rcases set have have rw exact simp exact have refine s_closed.Icc_subset_of_forall_exists_gt obtain have have rcases have filter_upwards have calc simp hu.left.le, rw apply simp exact have have filter_upwards apply have simp and_self_iff] refine exact have have filter_upwards self_mem_nhdsWithin] have rwa have filter_upwards have lt_min ht.2.2 rcases refine calc g apply rw exact rw apply exact calc g convert rw simp


rw convert sub_le_integral_of_hasDeriv_right_of_le neg_le_neg abel simp


set have refine filter_upwards unfold rw have rw refine exact rintro refine filter_upwards simpa


let have have refine simp convert simp_rw simp


rcases simp and_true] exact simp true_and] exact


refine integral_comp_smul_deriv rw exact


have intervalIntegrable_iff.mpr have have integral_Icc_eq_integral_Ioc filter_upwards intro rw constructor refine filter_upwards replace simp grind refine filter_upwards replace simp


wlog exact rw have have let have integrableOn_congr_fun filter_upwards intro refine rw refine all_goals


have let have intro rw rintro have conv_rhs apply simpa rw by_cases simp simp


have refine ext rw map_apply congr ext simp rw congr rw


have have simp rw convert rw exact congr have simp_rw rw rfl


rcases exact simp rw simpa hf.neg.intervalIntegral_add_eq_of_pos


suffices simp have induction zero succ simp rcases simp conv_rhs have rw simp_rw hf.intervalIntegral_add_eq


let let conv_lhs rw integral_add_adjacent_intervals rw exact


unfold rw congr apply intro norm_cast rw apply field


unfold rw norm_cast rw simp intro suffices rcases simpa exact


rw let let let have unfold simp simp_rw refine fun_sub have apply exact exact exact have let rw refine fun_sub rw exact have simp_rw grw have intro have have have replace have integral_eq_sub_of_hasDerivAt_of_le rw grw integral_mono_on integral_comp_sub_right simp have have key exact


rcases simp have have have rw exact have exact


have intro rcases simp exact have intro have filter_upwards g_nn rw congr exact rw simp_rw rw apply funext have funext by_cases simp have simp by_cases simp have simp simp_rw rw swap apply by_cases simp_rw rw swap rw show simp_rw rfl have funext cases mk rw by_cases have rw have rw rw have simpa measurableSet_region_between_oc exact


is have by_cases have have intro simp_rw apply exact simp have have filter_upwards simp rw by_cases rcases rw have rw calc have rw simpa filter_upwards rw exact apply rw gcongr exact have rw calc simp rw simpa apply apply apply filter_upwards exact rw not may integral). one sets this have contrapose have intro rcases exact have have rwa let have have have rw obtain exists_seq_strictMono_tendsto have intro obtain exists_lt_of_lt_csSup exact have apply rintro obtain exact mem_iUnion.2 let μ.restrict have obtain exists_seq_strictAnti_tendsto let set_mem finite intro have rw convert rw exact have rw apply by_contra rw have filter_upwards have have have exact refine rw apply exact spanning apply rcases exact obtain exact exact have have have apply have simp_rw apply apply apply simpa simp simp rw have have apply filter_upwards simp have apply rw congr exact have have rw rw exact


obtain refine exact have ae_mono have refine rw exact obtain refine filter_upwards rw exact have apply filter_upwards rw congr apply filter_upwards have filter_upwards rw congr refine have rw exact simp_rw exact


set have have lintegral_comp_eq_lintegral_meas_le_mul simp_rw rw congr simp


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


rw rw apply have have rw filter_upwards rw exact


constructor rintro have refine apply rw rw filter_upwards intro have rw filter_upwards intro simp simp rintro refine rw filter_upwards intro rw simp simpa


set set refine rw refine refine rcases have let have have intro rw refine by_cases simp simp subst have have have refine suffices exact rcases exact have intro refine simp_rw intro exact have measurableSet_le calc rw refine gcongr exact gcongr rw refine congr refine simp simp gcongr simp simp exact


simp_rw let have have intro by_cases exact simp rw simp_rw rw congr exact


have suffices rw exact rw refine filter_upwards tendsto_nhds_unique


classical let let have calc simp split_ifs rfl have simp exact


cases cases simp inhabit have intro refine exact calc refine exact exact


simp_rw let have filter_upwards obtain exact have intro obtain refine intro by_cases repeat apply_rules simp exact convert simp_rw rw congr ext1 rw apply exact


classical induction empty insert simp rw rw


classical simp rw simp intro exact intro use constructor exact exact


by_cases simp apply have have rw exact have simp simpa


refine intro rw suffices exact intro have have rwa intro rw rw congr exact


rcases exact rcases have intro simpa choose refine refine exact exact


rw refine by_cases let replace have exact have refine obtain use simp map_coe_ennreal_restrict, refine simp simp


rw have erw simp_rw rcases refine have rw refine norm_cast simp rfl


rcases have rw refine intro by_cases simp not_false_eq_true, exact exact


refine have by_contra refine calc obtain have ext rw rw constructor obtain obtain have rwa


rcases rcases rcases rcases use refine simp intro calc rw refine simp gcongr refine exact gcongr exact simp


simp apply have refine rw congr by_cases simp congr simp rintro contrapose simpa


apply apply congr simp split_ifs rfl exact


rsuffices exact wlog choose refine rw exact have simpa choose set have have refine rw refine iSup₂_le obtain rcases exact calc have have apply rw gcongr exact


is set have obtain set have have refine erw simpa


induction hs simp lintegral_indicator, have intro simp have rwa simp simp obtain refine refine exact simp simp univ_inter] rwa simp simp h₂ replace by_cases simp rcases refine simp by_cases simp rcases refine simp obtain rcases rcases refine apply rw exact apply rw simp


simp_rw rcases have convert rw simp rcases exact


rw intro have rw exact have replace rcases rw refine exact intro refine exact intro refine exact assumption refine apply assumption rw assumption


have have filter_upwards have tendsto_atTop_of_monotone rcases rw obtain refine exact exact classical let have filter_upwards simp_rw exact suffices have filter_upwards exact suffices ae_eq_of_ae_le_of_lintegral_le refine exact


have exists_measurable_le_lintegral_eq choose let have induction zero succ have intro cases zero succ have filter_upwards induction zero succ have apply apply filter_upwards rw exact have apply exact simp_rw exact exact filter_upwards filter_upwards exact


have refine filter_upwards have filter_upwards rcases refine rw exact exact classical let have filter_upwards simp_rw exact suffices have filter_upwards exact suffices refine exact refine exact


rw refine rw have exact rw lintegral] refine exact


rcases calc gcongr exact rw exact simp exacts


have intro simp have rw exact refine suffices simpa


simp_rw let have have intro by_cases exact simp exact rw simp_rw rw congr exact rwa


cases cases simp inhabit have refine le_antisymm exact calc rw exact exact refine exact exact


have suffices rw exact rw refine filter_upwards tendsto_nhds_unique


by_cases exact obtain obtain simpa refine exact ne_top_of_le_ne_top refine calc setLIntegral_congr_fun


obtain use refine rw gcongr rw exact exact


ext1 let calc rfl f apply apply exact simp_rw rfl


have induction empty insert ih rw simp_rw


induction empty insert ih rw have simp_rw


calc lintegral_mono simp rw rw hpq.inv_add_inv_ennreal] simp exact


let let calc refine rw fun_eq_funMulInvSnorm_mul_eLpNorm ring rw refine have have exact


by_cases refine exact by_cases refine rw exact by_cases exact by_cases rw exact exact


rcases rw simp rcases rw simp have rw linarith have have simpa


classical induction empty insert rcases simp have simpa calc congr apply congr apply have have let have have calc simp apply exact exact exact exact apply gcongr exact simp


suffices refine rintro exact refine simpa simp_rw exact rintro exact refine simpa


have have calc refine dsimp have rw exact have rw rw rw refine rw finiteness rw constructor fun_prop


have have have have have let let have calc simp_rw gcongr simp_rw exact rw have symm rw have rw simp simp_rw


calc gcongr by_cases rw exact by_cases rw exact refine nth_rw rw have have simp_rw rw rw gcongr exact exact


have obtain simp obtain simp by_cases refine simp_rw exact have refine symm exact have by_cases rw exact exact lintegral_Lp_add_le_aux


rcases simp norm_num rw calc rw gcongr exact rpow_add_le_mul_rpow_add_rpow


let let have apply exact have have apply intro simpa have calc apply apply intro simp have simp have have calc by_cases rcases refine calc rw have have apply intro simp simpa rw have have have have have apply intro simp have have rwa have ext simp simpa obtain refine calc rw simp rw field_simp


obtain rcases refine rw exact rw filter_upwards h'iφ] have have refine apply filter_upwards simpa have apply exact apply filter_upwards rw exact convert simp


let have refine apply apply simp right exact rw apply apply filter_upwards simp refine filter_upwards simp rw rw apply rw exact


have apply exact exact exact filter_upwards intro apply obtain obtain rcases refine simp simpa filter_upwards have suffices have have simpa suffices rwa calc δ apply rw simp not_le] exact have rw exact apply filter_upwards rw mul_inv_cancel₀ simp filter_upwards exact exact exact


let have have apply have exact simp convert conv_rhs rw integral_neg_eq_self] simp


induction zero simp succ have rw simp_rw simp have n_ih exact


induction zero succ calc f rw simp_rw rw


refine simp_rw convert rw apply filter_upwards rw simp


simp have simp_rw enorm_eq_ofReal have rw rw intro filter_upwards rw intro


rw apply apply filter_upwards intro exact apply filter_upwards


use rcases calc gcongr simp refine gcongr apply simp


rw refine tendsto_integral_of_L1 simp_rw apply exact swap change have simp_rw refine rw


rcases simp_rw simp exact simp_rw simp rw


let have let have calc congr apply contrapose have exact apply have intro contrapose have exact simp apply apply refine obtain exact apply have intro contrapose have exact simp congr apply contrapose have exact


apply simp intro apply exact exact apply simp obtain obtain exists_continuous_one_zero_of_isCompact refine exact


apply apply simp obtain obtain exists_continuous_zero_one_of_isClosed refine apply apply apply filter_upwards filter_upwards intro apply exact simp intro exact


rw obtain have apply nth_rw exact obtain exists_tsupport_one_of_isOpen_isClosed hKsubintV have use intro apply simp rw exact


obtain exists_lt_of_csInf_lt refine rw exact


apply intro obtain obtain exists_lt_rieszContentAux_add_pos have rintro exact exact le_add_left apply rw apply rw


intro simp refine rw intro rw have obtain exact refine apply intro lift obtain rw refine rw set have subset_interior_iff.2 preimage_mono have subset_closure set simp exact csInf_le


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


apply have rw apply intro obtain exists_lt_rieszContentAux_add_pos simp_rw refine intro by_cases simpa simp


rw apply intro rw apply rw use simp_rw refine apply rw


let let a ε have calc exact rw let use refine have calc intro simpa intro simp refine simp exact intro apply simp_rw intro rw simp_rw rcases left exact right exact intro simp constructor exact


have obtain let use refine intro suffices exact calc


have apply exact exact have simp obtain exact


let let apply intro obtain obtain exact obtain let replace obtain range_cut_partition dsimp field_simp simp let a ε have have refine apply dsimp rw exact f.2 obtain have have have choose exact obtain have calc obtain exact calc simp simp congr simp by_cases simp simp gcongr intro by_cases rw apply exact simp gcongr calc calc apply exact rw apply rw exact rw apply finiteness gcongr rw have apply exact have refine have linarith simp_rw have suffices simp exact dsimp rw exact rw linarith gcongr have intro apply intro dsimp apply dsimp exact calc refine dsimp exact have have calc y have simp_all simp mul_add, simpa


refine have have obtain exists_isOpen_le_add suffices rwa all_goals have obtain obtain exact have by_cases simp simp have by_cases simp simp calc μ.real refine exact refine exact rwa all_goals


let map_add map_smul monotone refine let hasCompactSupport exact


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


rw have simp_rw rw congr ext1 rw intro by_cases rw finiteness


induction hμs rw exact rw exact isClosed


suffices refine exact intro have rw exact


classical revert refine intro simp intro simp rw rw convert simp


classical let let have rw simp_rw refine filter_upwards refine filter_upwards simp_rw suffices refine filter_upwards suffices simp_rw exact rw exact


by_cases have have ext1 rw exact rw intro use refine intro rw let have eLpNorm_congr_ae rw have exact calc refine refine rw simp


have apply intro have refine rw exact rw intro rw refine have setToFun rw exact intro have rw


by_cases simp have rw simp refine simp rw


have have have suffices convert exact exact refine rw have convert rw congr refine rw refine dsimp rw


rw intro have have inter_mem obtain rw refine exact exact filter_upwards refine rwa


set have have rw circleIntegral_def_Icc] refine simp torusMap, refine simp congr simp imp_true_iff, have rwa


intro have rw refine have ext simp rw exact


unfold exact mem_union_right let mem_iUnion₂.2 rfl⟩


suffices intro apply intro replace unfold rintro exact exact simp_rw obtain exact apply intro obtain use


apply intro rw refine intro exact exact rintro exact intro choose simp_rw refine iUnion_mem_generateMeasurableRec rw exact


apply intro induction basic empty compl rw obtain exact generateMeasurableRec_mono iUnion simp_rw exact


suffices obtain exact rw exact intro apply intro have have have apply intro exact rw rw have rw apply rw exact rw apply_rules exact rw exact apply simp have rwa


have simpa choose have apply intro simp intro exact apply intro simp exact rw exact


refine by_cases exact exfalso simp obtain specialize exact


inhabit set g have intro rcases rfl exact set have classical refine hfm.dite simp exact


rw intro dsimp split_ifs subst dsimp exact exact


classical rcases refine convert rw exact


refine by_cases simp have measurable_pi_apply exact simp have measurable_pi_apply exact


have by_contra obtain obtain absurd simp absurd simp obtain use use


use simp_rw apply rintro rw refine rw simp


refine induction hC empty compl obtain classical refine simp exact simp refine refine refine refine exact rw simp rw iUnion choose have refine simp exact refine simp exact simp rw refine exact exact


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


MeasurableEmbedding.schroederBernstein

let suffices classical rcases let have refine apply have apply rw simp rw exact have compl_subset_compl.mpr let refine refine induction zero succ rw exact apply apply intro cases exact rw exact rintro rw apply rw rw intro specialize rw by_contra apply exact


constructor rintro rcases rcases refine exact


refine rw rcases choose refine rw exact haveI exact exact


IsCountablySpanning.pi

choose cases let refine simp_rw iUnion_univ_pi


classical cases apply refine apply choose simp_rw rw have ext by_cases subst simp rw apply intro apply grind apply rw apply exact


apply refine rcases rw apply intro apply exact rcases rw apply rintro apply exact apply rintro dsimp rw apply exact exact


refine simp exact simp intro replace simp exact


classical nontriviality inhabit set have intro rw exact have have intro contrapose exact set refine rw simp exact rw intro refine ext simp constructor rintro rwa rcases rw exact refine contrapose refine exact


classical let let refine exact rintro by_cases simpa simp contrapose apply simp have rw exact filter_upwards rw simp contrapose apply simp


nontriviality obtain h.exists_ae_eq_range_subset refine filter_upwards simpa


haveI obtain have rw exact rw intro rcases exact rw exact


constructor intro exact intro refine have have exact


classical constructor convert rw simp exact


classical nontriviality rcases choose choose set have have refine measure_mono_null refine rw apply rw refine rw convert rw refine exact


classical have rw grind simpa rwa rw refine grind


have convert simp fin_cases fin_cases rwa


classical conv_lhs rw rw exact rw exact rw exact rwa


classical conv_lhs rw rw exact rw exact rw exact rw rwa


calc apply have simp_rw exact nth_rewrite apply exact exact rw exact apply have simp_rw exact nth_rewrite apply exact exact rw exact


classical have simp exact have id simp exact have simp exact rw gcongr refine sum_addContent_le_of_subset simp exact


classical let have rw rwa rw refine intro simp rintro exact rwa refine exact


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


have simp set set have rcases grind rw grind


classical induction empty insert rw simp_rw simp simp rw refine rw exact


classical induction empty insert rw simp_rw simp refine exact


let have have refine intro rw exact simp_rw rw exact have rw addContent_accumulate simp_rw refine refine rwa rw exact


refine intro rw simp change by_contra exact exact


rw have ext1 simp tauto have ext1 simp tauto rw rw rw exact


obtain simp by_cases ext rw comap_apply₀ simpa have simpa simp


have rcases exact have conv simp rcases rw


have intro refine simp intro grw refine obtain rcases let convert ext1 rw exact refine intro refine refine rfl


have rcases suffices have simpa refine refine simp


rw refine intro rw intro rw simp rw haveI rw refine rintro let dsimp grw simp have have have grw rw simp rw haveI rw refine rintro let dsimp grw have have simp exact rw refine exact


MeasureTheory.Content.regular

have refine apply rw exact refine rw simp rcases refine exact


refine apply intro obtain calc μ.measure rw exact calc μ rw exact


have rw exact rw intro wlog have rcases have replace filter_upwards calc μ μ refine gcongr apply gcongr rwa rwa simp have obtain have filter_upwards rw refine rw gcongr have rw measure_diff_le_iff_le_add exact


rw intro replace apply rwa filter_upwards ht).eventually hz] w intro rw exact


classical by_cases lift rw simpa rw rw rw


by_cases have refine refine exact obtain exists_lt_of_lt_ciSup have by_contra simp simp have by_contra simp simp refine simp exact refine rw exact


have let suffices let refine simp rw simp refine rw exact simp rw suffices μ.sigmaFiniteSetGE μ.sigmaFiniteSetWRT calc μ.sigmaFiniteSetGE refine rw


apply refine exact le_iSup₂ measurableSet_sigmaFiniteSetWRT exact


suffices by_contra have exact intro have rw exact exact have conv_rhs refine have infer_instance exact le_iSup₂ exact


rw simp_rw suffices intro suffices have exact this intro refine exact


let let let have have have have have dsimp rw simp abel have refine refine exact exact have refine refine exacts have use rintro refine rw exact have have have have rcases exact rcases change have have let have simp exact have simp_rw exact have have simp_rw rfl have refine have simp_rw linarith intro refine calc γ rw rw abel exact let have have suffices exact tendsto_const_nhds.sub tendsto_const_nhds.mul tendsto_pow_atTop_nhds_zero_of_lt_one have refine exact refine have refine intro exact intro exact refine change refine exact have refine intro have calc γ rw simpa intro have calc γ rw rw simpa


have intro rcases exact have simp rw exact calc f rw exact


by_cases simp have let let have have have have have rwa simp have filter_upwards rw simp rw simp simp have rw congr refine filter_upwards rw have swap refine refine filter_upwards rw rw convert simp measureReal_def] simp


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


have refine rw rw exact rw rw refine exact


by_cases suffices lt_of_le_of_lt rw calc simp


suffices filter_upwards intro rw apply refine exact


have obtain obtain rw have rw refine rw have ext1 have refine rw exact have refine rw exact rw add_zero] have intro have rw exact rw ext1 have rw exact rw


by_cases rw by_cases refine rw rw refine rw infer_instance


by_cases refine exact rw swap convert ext simp rw rw refine rw infer_instance


refine exact exact ext rw μ.haveLebesgueDecomposition_add


have obtain obtain rw have rw refine rw have ext1 have rw exact have rw exact rw hadd, have intro have rw exact rw measure_inter_add_diff ext1 have rw exact rw diff_eq,


rw simp_rw rw suffices rw exact exact exact


have refine rw simp have ext simp rw rw simp simp_rw exact


rw suffices rw add_assoc, ν₂.haveLebesgueDecomposition_add exact exact exact


have obtain refine exact exact choose let have have specialize have rwa have have lift lift rw by_cases suffices by_contra have rw exact intro have refine positivity rcases have have rw exact exact refine rw exact rw simpa hA₃ rw have simp_rw obtain exact


set set rw constructor refine rcases exact exact refine exact


induction zero constructor simp intro succ hm have funext refine rw


wlog exact this set have have set set have measurability have refine rw refine refine simp have calc rw exact


refine rw simp_rw rw suffices ν.singularPart ν.singularPart rw withDensity_smul_measure, exact exact exact


rw suffices rw add_assoc, ν₂.haveLebesgueDecomposition_add exact exact


refine exact ext1 rw conv_lhs rw congr rw simp refine exact exact


let have have have have exact filter_upwards rw


have refine refine exact ext1 conv_lhs rw rw simp have filter_upwards simp rw refine filter_upwards exact


let have refine change have have rw filter_upwards rw refine simp suffices have exact exact


let have refine change rw withDensity_eq_iff_of_sigmaFinite have rw


have rw have have refine have have refine exact have rw exact filter_upwards rw exact


suffices ν.rnDeriv refine exact constructor filter_upwards simp exact exact


set have have calc refine exact exact simp gcongr exact apply


rw have have have have rw refine refine refine symm suffices rw exact refine exact exact


let have obtain rw exact let have refine rw simp simp_rw rw rw simp congr refine convert simp convert simp simp refine rw congr have have specialize obtain simp rw refine convert rw


constructor intro have simp by_cases simpa indicator_eq_one_iff_mem] simpa not_false_eq_true, intro ext by_cases simp have simp


obtain contrapose exact have obtain rw use simp lintegral_dirac apply refine intro rw simp


constructor contrapose exact intro have simp exact


let suffices rcases use filter_upwards rw grw exact intro induction zero succ replace filter_upwards grw


have rcases refine rcases have simp simp refine apply apply gcongr apply


refine rw intro rcases rcases have intro refine rw exact have exact


apply exact exact exact intro obtain exact


intro rcases have have exact have ae_eq_set_inter rw exact


has the positive obtain exists_seq_strictAnti_tendsto have exists_open_nhds_one_mul_subset choose let suffices replace apply exact rw refine exact intro choose obtain have apply have obtain refine have have exact have have have rw group simp by_contra have apply apply push contrapose simpa have exact


simp testAgainstNN_coe_eq] apply have intro have calc f have rwa


rw intro suffices apply constructor have rw suffices simpa have rw suffices simpa


apply have simp_rw simp_rw simp apply have simpa


intro apply intro have apply exact exact


apply intro apply have set have have have have have have simp_rw simpa


refine rw intro simp_rw set set have have have simp_rw exact


rw refine rw simp_rw refine exact exact specialize simp exact


refine apply have rw exact have rw exact convert


intro simp rw intro obtain have simp have congr simp exact rw have rw have tendsto_iff_forall_integral_tendsto.1 exact apply filter_upwards


let have let μ refine simp rw simp invFun continuous_toFun continuous_invFun rw exact left_inv μ ext simp rw exact exact exact exact exact exact right_inv μ ext simp rw simp rw rw exact exact exact exact


let have rw exact have intro rw exact apply intro have nth_rewrite apply nth_rewrite exact have apply squeeze_zero exact have exact


refine continuous_iff_continuousAt.2 small null let have rintro refine simp_rw exact apply rintro exact letI intro obtain have exists_null_frontier_thickening choose refine apply exact simpa calc univ.pi rintro simp apply exact


refine continuous_iff_continuousAt.2 small let have rintro refine rw exact rw exact apply rintro exact letI letI intro obtain rcases rcases simp refine simp exact calc ball rintro simp apply exact exact


rw intro induction empty basic compl simp exact iUnion


wlog rcases rw exact simp_rw join_apply clear suffices refine this exact exact intro rw swap fun_prop congr funext rw simp_rw exact


classical obtain obtain rw refine apply apply have rcases exact


classical rw rintro obtain change convert simp exact


classical rcases rcases rw refine rw gcongr


classical apply rcases have apply intro simp simp simp simp exact refine le_trans rw exact apply rintro simp refine constructor refine simp simp refine simp simp


rcases apply refine simp rintro simp simp refine


have refine let have have refine constructor apply simp apply exact


let have change apply unfold rintro apply


let have change apply unfold rintro rw apply


let have rw apply unfold rintro apply apply


rcases rcases rcases replace rcases rcases replace let have rw let apply mem_of_subset_of_mem simp unfold rintro simp apply rw refine refine exact refine exact apply


let have rw apply unfold rintro simp apply apply


a itself obtain obtain exact rwa filter_upwards obtain not_disjoint_iff.1 simpa


measure is follows projection have have rcases have infer_instance have have exact let obtain let have let have have let have have ext obtain have simp have rw rfl exact exact exact exact let let obtain have refine simpa have obtain have refine simpa refine simp rw


have have have have let have have have simp_rw rw simp exact


have unfold conv enter rw conv enter rw simp_rw exact


by_cases simp rcases simp rcases have have conv_rhs simp have simp calc simp


suffices refine convert rw intro let refine rwa simpa


simp let have rw ext simp refine simpa simpa rw ext have simp_rw simp_rw


have apply simp have convert ext simp rw let have apply intro refine ext simp rintro exact rcases left simp_rw simp image_id'] right simp_rw simp


ext simp zero_add, constructor rintro exact rintro choose refine simp_rw


ext simp_rw constructor rintro specialize simp_rw rcases rw exact rw exact intro refine specialize rcases rw exact rw exact specialize simp rcases rw rw rw


ext simp constructor intro rcases constructor use constructor exact simp use constructor exact simp intro rcases use constructor constructor change aesop change aesop ext simp simp


apply ext have let haveI have have suffices rw rfl have rw symm suffices rw convert exact exact exact


obtain have rw by_cases convert rw apply rw exact rw simp rw convert


obtain let haveI rw have ne_top_of_lt obtain rw erw apply intro have apply exact exact refine measure_mono_null fund_dom_s.measure_zero_of_invariant rw change exact change apply refine apply exact


apply rw intro apply simp apply apply simp apply apply exact exact exact


set have contrapose have rw exact set have haveI clear_value lift exact apply exact exact rw exact


set have apply intro rw rw apply intro ext rw congr convert exact


let have have exact calc have have refine have rw exact have simp_rw exact apply


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


rcases simp let have have intro have apply apply exact exact apply exact calc apply apply exact exact let have let have let have have have rintro by_cases simp have apply contrapose simp apply simp exact simp apply exact congr rw simp apply apply exact let have let have let have have have rintro by_cases simp have apply contrapose simp apply simp exact simp apply exact simp_rw congr conv_rhs


have obtain exists_continuous_nonneg_pos have ne_of_gt apply calc c rw rw exact


functions, obtain exists_seq_strictAnti_tendsto let have apply exact have intro apply exact apply simpa refine by_cases simp norm_cast exact simp rw simp simpa filter_upwards have tendsto_pi_nhds.1 simp convert simp have apply apply simp rw simp simpa have simp_rw have tendsto_nhds_unique have have ext exact have simpa have rw simpa


apply let change obtain exists_continuous_one_zero_of_isCompact let have have have have apply exact have rwa exact exact exact exact


let apply calc μ measure_mono apply exact exact calc ν measure_mono apply exact exact


let change obtain rcases exact have let obtain apply intro refine simp intro simp exact rintro simp rcases rcases obtain exact intro exact obtain have intro by_cases have have exact obtain simpa have rw have exact exact rcases simp simp by_cases rcases have apply have exact simp have have rw have rw rw congr apply have exact have intro have contrapose have apply have exact exact have have refine refine exact rw have exact have have apply obtain refine apply exact rw


up let have intro have rw congr exact let have have apply exact exact have apply exact exact simp apply exact exact exact


have intro rw congr exact ext rw congr exact


have have isMulLeftInvariant_eq_smul rw exact


constructor let have have rw have rw simpa have have conv_rhs simp have this have rw


obtain exists_continuous_nonneg_pos have apply rw integral_domSMul] refine exact rw exact


let have have rw exact simp_rw rw have ext rw exact rwa


convert_to rw simp apply intro by_cases simp simp


have constructor have simp simp have have simp_rw exact


let invFun left_inv right_inv rw refine rw simpa


classical induction empty insert simp rw exacts hI


rw refine set have have have have calc μ have refine rintro rw rcases exact mem_iUnion.2 by_cases rw exact suffices calc μ have refine rw suffices refine rw intro rw exact suffices hij.lt_or_gt.elim intro have refine have rcases have apply refine refine rw


refine rw refine iInf_le_of_le iInf_le_of_le rwa


rintro refine tendsto_nhds_unique_of_eventuallyEq rw filter_upwards rintro refine rintro have exact


classical rcases refine le_of_tendsto_of_tendsto simp rw refine simp split_ifs apply exact simp


simp refine rw congr apply intro simp intro apply simp


classical simp refine surjective_id.iSup_congr iSup_congr_Prop dsimp by_cases rw congr simp rw push_neg refine rw exact rcases exact


haveI simp refine refine rcases set refine refine rw exact calc tsum_iUnion_decode₂


by_contra suffices rcases exact intro refine have rw exact filter_upwards rintro lift rw rcases rcases simp simp have rw refine rw


apply let let have simp simpa rw suffices apply convert rfl simp intro rcases have calc


rcases rcases simp have have rw rcases simp rw exact haveI simp have have simp refine have rcases refine le_iSup₂_of_le iInf₂_mono iInf_mono grw refine simp intro simp rw exact


have simpa refine rw dsimp rw refine rw simp


rcases rcases simp have haveI have exact rw rcases simp rw exact haveI simp have have simp refine refine refine replace refine exact refine simp rw exact


classical refine simp intro choose obtain replace apply le_antisymm have refine rw exact rw exact have let let have simp have refine intro refine simp add_sub_add_left_eq_sub, have refine have intro simp simp let apply gcongr exact refine simpa refine calc gcongr exact calc x gcongr exact calc μH liminf hausdorffMeasure_le_liminf_sum refine filter_upwards apply simp intro exact isBoundedDefault simp simp apply refine apply apply intro simp simp


obtain haveI obtain simp simp have suffices simpa have refine rw rw iso_smul.hausdorffMeasure_image


have calc μ.real congr simp rw inv_mul_cancel₀ rw congr rw gcongr refine setIntegral_mono_on exact exact have intro simp linarith rw norm_num rw refine exact grw simp exact gcongr exact norm_cast rw congr ring_nf rw rw simp rw integral_charFun_Icc simp


have convert rw simp exact simp rw simp_rw


haveI simp preimage_const_add_Ioo]⟩ have change rcases simp conv_rhs rw simp


refine rcases simp preimage_const_mul_Ioo_of_neg simp mul_sub,


refine simp rw swap have ext simp diagonal_toLin'] have intro have simp exact rw abs_one, rw simp


translation, have refine refine have simp_rw rw refine simp_rw ext cases mk simp lintegral_add_right_eq_self


apply intro conv_rhs rw one_smul] intro simp_rw intro rw apply apply apply apply


classical rw have funext rw split_ifs have simp have simp dsimp rw exact


have have apply apply exact rw convert rw exact rw exact


refine change rw ext simp exact change rw ext simp exact


two let let have obtain isOpen_iUnion_countable have intro by_cases rw obtain simpa right exact exact apply rw constructor have simp rintro dsimp rcases simp exact


two let let have obtain isOpen_iUnion_countable have have rw rintro change rcases simp exact filter_upwards intro by_cases rw obtain simpa apply exact


obtain obtain have have isBounded_range_of_tendsto apply intro simp intro have convert simp have simpa have convert rw exact


rcases rw rw rcases simpa measure_preimage_add_right]


let haveI have have obtain have rw have ext simp simp have have have rw haveI have rw ecomp,


rcases let change rw congr simp have exact


rcases rw rcases simp rw by_cases haveI simp haveI simp


obtain simp obtain simpa obtain refine rw rw


apply have refine exact simp refine filter_upwards rw exact


have apply filter_upwards rintro grw rw have apply filter_upwards rintro have simp singleton_add_closedBall, simp simp have apply simp simp apply filter_upwards rintro calc μ μ rw


set set have apply simp inv_eq_zero, refine rw have apply exact filter_upwards intro rw exact rw apply filter_upwards rintro have have dsimp rw


have apply apply refine gcongr apply filter_upwards rintro apply rw exact refine congr apply simp apply


obtain exists_subset_measure_lt_top filter_upwards intro have have apply exact


have hfg.mono rw lintegral_congr_ae, dsimp rfl


refine integrable_of_summable_norm_restrict mul_nonneg simp mul_one, intro have simpa exact


have refine rw by_cases have rw let rw simp_rw exact calc rw rw congr rw refine rw have contrapose exact rw


letI letI dist dist_self dist_comm dist_triangle edist edist_dist eq_of_dist_eq_zero letI letI letI have let let convert rw congr simp_rw rfl refine exact let have rw rfl


letI letI dist dist_self dist_comm dist_triangle edist edist_dist eq_of_dist_eq_zero letI letI letI have let let convert rw congr simp_rw rfl refine exact rw congr simp_rw rfl refine exact


have have have refine exact have simp have have have have have have norm_smul_le simp_rw convert nm_neg rw exact simp_rw rw integral_exp_neg_rpow rw


have have obtain have ext refine exact rw rw convert simp_rw mul_rpow abs_eq_self.mpr rpow_lt_rpow_iff div_mul_cancel₀


have have toReal_ofReal have simp have have have have have have norm_smul_le simp_rw rw volume_sum_rpow_lt


have have have refine exact have simp have have have have have have norm_smul_le simp_rw convert measure_lt_one_eq_integral_div_gamma nm_neg rw exact simp_rw rw rw


have have toReal_ofReal have simp have have have have have have norm_smul_le simp_rw rw


obtain rw suffices rw rw simp convert simp rw


apply intro by_cases simp apply intro simpa


by_cases simp by_cases simp apply intro have let let have have have simp_rw add_comm have rw finiteness finiteness rw refine calc μ grw calc κ grw


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


apply intro refine have apply rw have specialize rw have rw apply rw


apply apply intro have refine exact simpa convert exact


refine intro set set rw refine intro by_cases simp simp have apply intro apply obtain have have rw refine rw linarith rw have have filter_upwards hn simp specialize have grw mul_comm] gcongr calc δ positivity rw apply rw rfl exact simp refine


by_cases exact by_cases simp have apply lt_of_lt_of_le exact exact filter_upwards simp convert exact


cases refine disjoint_of_subsingleton⟩ intro simpa subsingleton obtain have set set refine exact exact intro apply convert ring have convert exact simpa exact


rw intro rw intro have have obtain obtain have simp obtain refine have simpa simpa have set have have filter_upwards simp apply rw apply levyProkhorovDist_le_of_forall_le set have suffices refine intro simp obtain by_contra simp obtain exact intro obtain simp by_cases refine simp exact exact have intro simp obtain rw obtain obtain refine apply linarith apply specialize hQ apply rw apply exact


simp have filter_upwards hx_ne_top rw simp rw rotate_left rw simp rw simp ring


simp have filter_upwards hx_ne_top rw simp rw rotate_left rw simp rw simp rw ring


cases inl inr h0 filter_upwards hμν.ae_le rw simp exact simp push_neg exact simp


cases inl have simp inr h0 filter_upwards hμν.ae_le rw exact refine simp


calc integral_congr_ae rw swap rw swap simp


suffices clear rcases by_cases have simp congr apply exact have intro exact simp


refine set have have rw exact have rw calc μ.map


refine by_cases rcases calc μ set have refine calc μ measure_mono subset_inter measurability rw exact calc μ


rcases generalize replace suffices simp bot_eq_empty, exact clear refine le_antisymm set set have calc μ iSup_le rcases calc


rcases have rw measure_diff congr refine rcases use rw gcongr exact


refine have rcases calc refine rcases rcases exact refine rcases exact


let have suffices let rw exact have rw exact


by_cases have rw infer_instance simp_rw apply rwa exact simpa rw rcases simp


ext have ext simp refine exact exact rw rw have have intro obtain obtain rw refine exact have obtain rw exact rw congr have obtain rw exact


rw refine simp intro have intro rw exact rw exact


rw refine subst set refine by_cases refine simp refine simp simp rw exact simp intro simp simp set suffices have have simp_rw refine obtain refine by_contra simp exact have refine have conv rw refine rw intro rw intro rw simp rw rintro rw exact


refine let have have have have conv_lhs rw exact exact rw refine simp exact


have simp_rw have intro obtain refine norm_cast exact exact choose refine refine eq_zero_of_le_mul_pow rw refine exact


have convert push_cast rw norm_cast rw push_cast simp simp choose refine rw refine rw exact rw


have rw rfl intro rw ext simp rw exact measure_inter_null_of_null_right exact exact


rw intro refine rw exact rw exact rw inter_union_compl,


simp_rw obtain rw have refine simp refine simp


replace simp have refine rcases exact replace exact


apply have calc μ have calc limsup_le_limsup infer_param infer_param


rcases simp apply intro have let have have obtain have have have have apply rw apply simp


letI rcases simp have let have have have have have apply intro have tendsto_measure_cthickening_of_isClosed have specialize simp obtain have refine rw apply


refine specialize have refine exact exact exact have simp convert simp


refine specialize have have simp convert simp


classical obtain have choose rcases refine refine have intro simpa apply rw exact have contrapose simp rcases have have rw rcases refine convert simp simpa


and a of that lemma rcases simp apply intro refine obtain ν.exists_lt_measure_biUnion_of_isOpen have filter_upwards exact


apply simp intro simp_rw apply exact exact


by_cases simp exact simp_rw rw rw have exact


have have have simp_rw exact have filter_upwards intro apply simp_rw have refine exact exact exact


induction empty basic obtain classical compl ihs simp_rw exact iUnion ihf have rw exacts simpa


have refine intro simp suffices exact rintro simp conv exact intro have conv exact


apply set have have set have set have calc μ


constructor rintro rcases refine simp constructor exact exact


IsUnifLocDoublingMeasure.prod

constructor use filter_upwards hνr rw grw


ext have rw exact have refine rintro exact intro simp_rw intro simp_rw


ext have simp_rw exact have let let refine refine isCountablySpanning_measurableSet exact exact rintro exact intro simp_rw intro simp_rw


rw have ν.map rw congr simp refine rwa rwa


have sum sum ext rw exact rw congr ext1 refine intro simp_rw


have sum sum ext rw simp rw map_sum congr ext1 refine rintro simp_rw


rw restrict_sum_of_countable] congr ext1 refine rw


have use rcases simp have obtain rw infer_instance ext rw apply filter_upwards rw


by_cases ext1 rw have contrapose exact simp


ultrafilters function measure. for apply have simp apply simp filter_upwards simp refine calc simp gcongr exact gcongr simp exact intro apply exact calc gcongr exact simp intro apply exact simp gcongr exact choose let map_add g have convert rw exact exact exact map_smul g have convert rw exact monotone hgg apply apply exact exact let have let hasCompactSupport have apply gcongr apply filter_upwards let refine simp rw exact change apply let hasCompactSupport convert change simp rfl


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


for each there, countable. not our space proved inner sequence have rw exact exact have simpa isCompact_accumulate apply isCompact_iff_ultrafilter_le_nhds'.2 have ν obtain simp rw apply simp filter_upwards simp refine convert apply apply exact le_trans obtain ν'.InnerRegular apply rw exact hν.2 let refine apply convert exact choose have simp have apply have simp rw suffices convert simp have apply exact apply filter_upwards rw exact le_trans hμ.1 let have apply rw intro have have simp rw simp_rw apply apply exact exact have have simp exact rcases have f apply apply tendsto_finset_sum filter_upwards calc dist dist dist dist gcongr have rw simp nth_rewrite rw simp calc apply filter_upwards simp filter_upwards simpa ring refine simp rw exact rcases have rw simp intro have let map_bounded refine simp exact exact apply filter_upwards calc apply filter_upwards apply filter_upwards by_cases simpa simp apply apply simpa suffices apply convert simp simp have apply filter_upwards have apply simp intro apply rw exact rw suffices apply simp gcongr simp suffices convert simp have apply exact apply filter_upwards have rw exact exact rw exact


apply have ext simp refine rintro simpa rintro let have exact rw exact


obtain exists_seq_strictAnti_tendsto have rcases refine have exact choose let have apply exact right simp intro apply exact apply intro calc μ gcongr simp apply exact


rw obtain replace replace rwa rw replace convert rw replace rwa


obtain refine exact have exact simp exact


intro let replace rw exact have rw inv_mul_cancel, change exact


classical induction empty insert simp exact


refine have have obtain refine inter_subset_right.trans rw rcases rw have intro have have rw exact rcases rw exact choose refine calc μ


intro have have rw rcases rw rcases exact


rintro rw obtain have apply rw exact refine apply rw exact refine calc r rw congr apply exact


intro set have have rw rcases refine exact


rintro have have obtain simpa obtain use simp rcases rcases replace rcases refine calc μ


have suffices refine innerRegular rcases rcases refine rw exact apply intro rcases exact rintro rcases refine simp intro have rcases choose have rw exact rcases refine isClosed_biUnion_finset calc rw gcongr apply gcongr exact rw exacts calc μ


intro set have have have rw exact rw rcases exact


constructor intro simp rcases simp rcases exact rcases simp rcases exact rcases rcases rcases refine apply simp gcongr


constructor intro have simp exact obtain simp exact rcases refine simp exact


rcases have obtain exists_isOpen_lt_of_lt refine rwa


have rcases rcases refine rw gcongr calc μ apply exact exact


by_cases simp infer_instance by_cases constructor intro by_cases simp simp constructor convert have simp


constructor refine rintro exact rintro exact


have constructor intro have rw exact exact


constructor rcases exact rcases refine simpa exact


constructor obtain refine simp exact obtain refine simpa exact


intro obtain obtain refine refine simp refine have exact


of letI cases refine rwa let have obtain choose let have have refine exact rw choose rcases classical let refine rw refine refine have simp exact


constructor intro have have have obtain use rwa


suffices convert simp exact refine exact rintro rw exact


ext rw measure_toMeasurable_inter congr grind


refine rintro ext1 simp rcases calc μ simp


classical induction empty insert simp rw


refine ext1 simp induction empty basic compl have rw rwa exact iUnion ihf simp simp


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


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


refine obtain h.exists_measurable_subset_ae_eq have apply filter_upwards have filter_upwards change simp tauto exact


rw induction hC obtain rw exact empty compl ht simp exact iUnion dsimp rw exact


rw refine by_cases simp simp intro simpa


classical refine refine let let let have measurableSet_biInter have refine exact simp_rw have intro simp_rw have have exact have intro simp exact have rw exact have mem_C calc restrict_biUnion_le rw congr rw rw congr by_cases simp refine by_cases simp have have exact nsmul_le_nsmul_left calc rw refine exact rw exact


obtain refine rintro obtain refine simp_rw simp have rintro refine have obtain refine rw calc have rw gcongr exact rw mul_div_cancel₀


refine rcases have set have have rcases let let refine let have have have rintro use exact refine intro apply rw intro have have have rcases have refine rw refine rw calc mul_le_mul_of_nonneg_right rw exact mul_le_mul_of_nonneg_left rintro rw intro rcases rcases let let sg refine simp calc congr


have rw refine le_antisymm rcases rw apply simp obtain exact


intervals, compactness the still very slightly will of as not refine rw apply rcases have simp apply let have rcases obtain have refine exact have have exact have have intro have conv lhs rw simp rcases have rintro apply simp by_cases refine rintro simp exact have have apply refine exact rcases exact choose have calc calc ofReal


refine have simp refine simp rw refine le_trans rcases simp f.length_empty, simp f.mono simp le_sup_iff, simp max_eq_left,


refine rw refine rcases grw rw choose show intro rcases refine simpa have conv lhs rw simp rcases rw rw refine calc f.outer simp simp simp apply apply apply exact


by_cases have apply simp simp apply rw apply rw simp obtain obtain exists_seq_strictMono_tendsto replace have refine replace have simp have rw refine exact exact have simp have apply exact exact exact


rcases have simp measure_union simp symm simp


rcases simp symm simp have have have simp rw simpa simp simp


rcases simp symm simp have simp f.mono.le_leftLim


have cases have rw rw have refine simp_rw exact


have cases have rw rw have refine simp_rw refine apply obtain obtain simp refine apply exact filter_upwards exact


have cases rw simpa have obtain rw exact


cases infer_instance obtain rcases obtain grind exact obtain rcases obtain grind exact exact


refine obtain exists_Icc_mem_subset_of_mem_nhds exact


ext cases inl have rw simpa rw exact rw exact inr have rw simpa rw exact rw exact


refine have rcases simp exact tendsto_nhds_unique simp rw ring_nf


refine simp change have rcases simp rfl exact rw rfl


let simp rw rw apply have ext1 simp rw have rw apply apply simp apply intro rw apply rw apply


repeat have rw apply refine intro rw refine refine rw intro repeat refine rw apply rw apply rw have exact ext1 simp refine refine rw exact


simp tsub_le_iff_right, refine obtain exact obtain exact


rw intro let cases inl have obtain refine simp rw rw exact inr


MeasureTheory.IsTightMeasureSet.map

rw simp intro obtain refine by_cases swap rw refine simp exact


have lift obtain simp by_contra choose obtain have calc have have simp_rw rw exact use simpa apply simp use intro refine exact use use simpa apply use simp intro apply refine rw apply norm_cast have simp_rw rw have suffices filter_upwards linarith


rcases simp convert simp have have have refine have intro calc gcongr intro simp have rw by_contra exact gcongr exact refine gcongr exact refine rw refine exact


refine have rw by_cases simp refine filter_upwards simp have h.comp refine intro have refine simp rw rw exact positivity refine exact


cases inl inr simp by_cases simp congr rw simp


have refine filter_upwards rw refine filter_upwards rw


by_cases rw simp refine exact exact filter_upwards simp have exact simp rw simp


by_cases rw simp refine exact filter_upwards simp have exact simp rw simp


by_cases rw congr suffices rw refine simpa exact have exact simp rw simp


cases inl inr rw simp_rw have intro rw ring simp_rw rw


cases inl inr ext1 rw congr rw congr simp have simp


cases inl inr refine exact filter_upwards simp exact


by_cases simp have rw calc congr rw positivity congr rw rw simp have exact


cases inl inr refine exact filter_upwards simp exact refine filter_upwards congr rw exact


cases inl inr have filter_upwards rw exact


refine refine set_mem finite spanning calc


have biUnion_mono have apply intro simp obtain obtain have contradiction have simp convert


simp have have suffices rw convert rw abel


set replace inhabit have rcases simp rcases simp exact


haveI constructor rw apply induction empty basic compl rw iUnion


refine use simp rintro exact rintro refine intro rcases exact


suffices cases exact set_mem finite spanning inhabit let obtain isOpen_sUnion_countable rw have by_contra rw simpa obtain have intro apply rw exact refine set_mem finite spanning refine obtain have simpa obtain exact


rcases simp rcases simp have infer_instance


classical obtain refine rcases rw infer_instance rw infer_instance


set rcases set have have simp rfl simpa iUnion_Ici_eq_Ioi_of_lt_of_tendsto rw refine exact


rw have intro by_contra simp rw simp_rw simp exact apply refine apply exact exact exact


let obtain rcases exact obtain exists_seq_strictMono_tendsto have choose have refine apply apply exact refine symm apply rw apply simp exact simp


have let have have refine refine rw apply apply calc m measure_toMeasurable_inter rw split_ifs apply exact exact


have let have intro simp_rw exact set have calc t rw intro rcases refine have exact refine apply calc μ rw exact congr ext1 apply apply calc μ gcongr exact congr ext1 rw refine exact rw exact intro refine exact rw rw split_ifs apply exact exact


refine haveI let have have simp_rw by_cases rw exact obtain by_contra have simp exact rw exact


MeasureTheory.sum.sigmaFinite

cases have refine rw rintro exact rw simp_rw exact


constructor intro let apply have rw swap simp simp convert ext simp intro let have intro rcases simp left apply exact apply apply rwa rcases have apply filter_upwards rw exact rw have rw filter_upwards simp


rw simp rcases have filter_upwards simp exact exact


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


apply intro simp intro simp intro have simp


let have rw let calc apply apply have rw filter_upwards intro simp have filter_upwards intro simp simp apply filter_upwards intro simp


refine rw refine have intro dsimp rw exact refine refine rw apply filter_upwards intro rcases have simp simp apply dsimp rw


let calc apply filter_upwards intro rwa apply filter_upwards intro simp


change rw suffices refine rw filter_upwards simp


refine rw simp simp have exact measure_mono_null nonpos_iff_eq_zero.1


MeasureTheory.SigmaFinite.withDensity

refine rw apply exact exact rw refine exact simp


wlog rcases exact wlog rw have infer_instance set have have calc μ.withDensity simp rw congr rw have refine simp have rw exact rw infer_instance


refine rw lintegral_withDensity_eq_lintegral_mul₀ refine rw simp all_goals


choose intro obtain refine not_eventually.2 on_goal calc volume gcongr exact have rw mul_div_mul_left all_goals


choose intro obtain refine not_eventually.2 on_goal calc volume volume gcongr rw refine rw exact dsimp have rw mul_div_mul_left all_goals simp_all exact


refine measure_mono_null by_cases simp refine rwa exact


classical refine refine refine have simp intro have rcases clear rcases exact have refine rwa rw


classical lift induction empty insert simp exact


apply intro have convert simp simp grw refine rw gcongr exact


apply refine refine le_trans rw exact rw exact rw exact


by_cases rw apply funext apply obtain exact


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


rw constructor intro exact intro conv_rhs refine intro refine intro refine intro refine gcongr


simp exact inducedOuterMeasure_eq_iInf s


simp by_cases simp simp exact have intro have rcases exists have intro refine simp choose refine have tendsto_const_nhds.add rw refine exact refine refine exact


refine rw rcases rw rw refine rw exact rw


refine rw refine calc m refine rwa refine exact


suffices rwa refine congr intro rw refine congr rw exact


rw intro conv_rhs refine let have classical have eq_add_disjointOfDiff_of_subset simp_rw rw refine refine rw exact apply le_trans simp apply apply intro simp_rw rw obtain simp exact


rw apply exact simp_rw refine by_cases exact simp push_neg obtain have exact


refine set rcases calc μ set have have calc μ μ.mono let mem_iUnion.2 calc μ add_le_add


refine rw apply rw refine refine rw refine rcases exacts


refine simp intro refine rw exact refine simp


refine refine simp preimage_iUnion] refine exact


refine simp refine rw exact refine simpa subset_rfl


classical induction singleton cons ih simp refine refine exact


classical induction rcases refine simpa inter h_t rcases rcases use constructor ext simp_rw grind intro split_ifs refine exact exact exact rw apply


classical have suffices ext simp rfl rcases refine ext constructor simp intro have revert rw apply intro simp_rw obtain have rw apply apply


ext1 simp refine rintro simp by_cases have ext1 rw exact simp exact have ext1 simp exact simp rcases refine rw rw rwa simp refine simpa


refine rintro refine exact rintro refine rw rwa exact simp


classical rintro simp_rw let have use have rw simp_rw ext1 simp grind refine simp split_ifs refine rw suffices refine refine grind simp simp exact


have rw rfl suffices intro induction basic empty


refine induction hC clear induction base empty compl union empty compl iUnion


induction base u_mem refine simp⟩ rw exact empty exact compl rcases have have refine hf rcases rcases rw exact ext simp mem_setOf_eq, constructor choose exact rcases exact union rcases rcases refine rintro exact exact rintro exact exact


let have apply have ext simpa exact let let have let have have intro rcases exact exact


intro suffices have specialize simp refine rwa rw exact


classical induction empty simp refine simp insert rw have obtain let have intro exact have hC.pairwiseDisjoint_disjointOfDiff have have intro rw exact let have intro simp exists₂_imp] intro exact refine rw refine simp simp_rw intro have by_contra refine refine exact convert rw congr rw congr exact rw simp_rw simp rw refine by_cases simp rw simp simp


by_contra rw obtain have hC.disjoint_sUnion_disjointOfDiffUnion simp refine rwa


classical induction empty cons rw obtain let have have use simp sUnion_insert] have have apply intro exact_mod_cast simp refine apply intro rw exact intro have refine disjoint_of_sSup_disjoint_of_le_of_le simp apply exact have refine rw rw exact_mod_cast exact intro rw exact simp refine rw exact simpa simp intro obtain obtain obtain exact intro simp_rw change rw exact refine intro rw exact simp simp_rw simp


classical induction empty insert simp_rw refine exact


classical induction singleton cons simp_rw simp refine exact


rcases simp have filter_upwards refine filter_upwards exact


intro have isDiscrete_iff_discreteTopology.mp rw apply


constructor rintro rfl rw intro by_cases exact simp_rw


symm calc v rw rw exact exact exact rw exact exact exact


classical induction empty insert ih simp rw exact grind simp exact apply apply


set have have rw apply convert dsimp rw rw exact exact


refine ext1 have rwa measureReal_eq_measureReal_iff] congr


ext rw measureReal_nnreal_smul_apply] rfl


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


cases rw refine intro measurability intro rcases simp simp


constructor refine rw intro by_cases rw exact exact


obtain obtain refine rw rw rw hv₂, exact exact exact apply by_cases exact rcases exacts rcases


refine simp_rw rfl intro have have intro exact simp s.of_disjoint_iUnion have s.nonneg_of_zero_le_restrict rw refine simp_rw exact


cases zero rw rcases exact succ rw have refine convert exact rcases exact


classical by_cases exact push_neg set have have refine rw have intro refine refine exact suffices rw exact refine intro convert ext rw exact convert ext exact intro intro refine refine exact apply intro simp intro exact


have by_cases by_cases swap set set have intro convert ext simp exact have rw exact exacts restrictNonposSeq_disjoint] have rw apply exact have have refine exact exact have simp exact have have refine by_contra rw obtain have rw obtain refine have norm_cast have rw exact obtain have apply intro rintro exact refine convert exact


simp_rw by_contra have choose have intro rcases exact choose set have intro refine rw refine have refine exact exact rcases exact


obtain choose have have set have have have apply refine rw of_union refine have restrict_le_restrict_iUnion let h refine exact exact exact refine rw intro by_contra rcases have rw linarith refine refine exact exact


obtain refine refine rw show zero_apply, exact refine rw show exact


obtain simp ext rw toMeasureOfLEZero_real_apply simp rw exact


have rw have have nonneg_of_zero_le_restrict linarith


rw on_goal have have rw of_union rw constructor linarith linarith assumption assumption


the show intro obtain obtain rw obtain of_symmDiff_compl_positive_negative refine ext1 have rw show conv_lhs rw show refine exact have rw show conv_lhs rw show exact exact rw exact


constructor refine obtain rw toMeasureOfLEZero_apply rw simp refine rw exact


constructor constructor all_goals refine have rw exacts refine rw


constructor rintro obtain obtain refine rw toMeasureOfLEZero_apply simp rw toMeasureOfLEZero_apply simp rintro exact null_of_totalVariation_zero


constructor rintro obtain refine rw toMeasureOfLEZero_apply simp rw exact rintro refine rw exact


by_cases lift exact refine rw infer_instance negPart rw infer_instance


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


have singularPart_mutuallySingular refine rw rw


have rw change rw refine use refine rw negPart use refine rw


have rw rw congr have refine rw have refine rw


by_cases refine convert exact rw refine rwa


cases inl lift exact inr rw conv_lhs congr congr rw congr rw rw


conv_rhs ext rw apply rw integral_re change rw exact rw integral_im change rw exact


have haveI ext rw integral_toReal refine conv_rhs exact


refine cases inl inr subst simp and_imp, exact


simp split_ifs subst simp forall_apply_eq_imp_iff₂, exact simp simp intro cases


cases inl have let exact inr subst let exact


rintro let have let have have let have let have have constructor refine apply refine rw rw


apply simp exact exact rintro let have let have infer_instance


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


rw let letI letI rw refine simp exact id)) simp


classical simp conv generalize induction


classical let zero_mem add_mem intro simp rw exact have let have intro rw rcases simp rcases rw refine rw exact rcases refine convert_to ext simp vadd_eq_add, grind refine intro rw rw by_cases simp replace apply refine rwa apply simp rcases induction by_cases simpa have have apply refine rwa apply simp rcases rw apply exact exact simp rwa


classical suffices haveI exact intro induction obtain exact rcases convert_to ext simp grind refine simp apply grind


rw rcases change simp apply convert isSemilinearSet_setOf_eq simp


classical haveI rw rcases rcases simp_rw refine convert isSemilinearSet_setOf_mulVec_eq simp


IsSemilinearSet.inter

rcases rw apply rw rcases rw rw apply apply


rw intro rw specialize rw specialize simp_rw rw refine conv_rhs simp rw simpa


classical rw apply rw convert ext simp congr ext simp


classical haveI apply intro rw refine rw apply rw exact exact


classical simp apply simp_rw rw rcases simp_rw apply simp


classical suffices induction mem rw simpa zero add


rw simp rw conv enter rw trans conv refine rw exact simp


simp rw simp rw conv enter rw rw simp conv enter rw rw


classical intro constructor rw simp rw simp


classical nth_rw simp constructor rintro refine rw exact rw exact rw intro refine sum_mem rw conv_rhs convert split_ifs simp simp simp


classical convert_to ext simp constructor intro refine exact refine simpa refine simpa rw tsub_add_cancel_of_le add_assoc add_zero exact intro refine apply rwa hs.fract_add_of_mem_closure hs.fract_add_of_mem_closure hs.fract_add_of_mem_closure rw rcases apply rw hs.floor_add_of_mem_closure add_assoc simpa refine rw apply apply rw apply apply rw apply haveI convert simp


classical convert_to ext simp constructor intro refine exact refine simpa refine simpa rw tsub_add_cancel_of_le add_zero exact intro refine apply rwa hs.fract_add_of_mem_closure hs.fract_add_of_mem_closure hs.fract_add_of_mem_closure rw rcases apply rw hs.floor_add_of_mem_closure succ_nsmul', simp refine rw apply apply rw apply apply rw apply haveI convert simp


convert hs.isSemilinearSet_setOfFractNe.union hs.isSemilinearSet_setOfFloorNeg.union ext simp grind


IsSemilinearSet.proj

convert ext constructor intro exact rintro refine simpa


IsLinearSet.closure

rcases convert ext simp constructor intro induction mem rcases exact zero add rcases simpa rcases exact refine simp_rw rintro simp simp_rw rcases rw refine nth_rw exact


IsSemilinearSet.closure

rcases induction empty insert simp_rw simpa


IsLinearSet.isProperSemilinearSet

classical rw rcases induction subst by_cases exact rw rcases simp convert_to ext simp constructor rintro rw rcases induction subst by_cases convert ih conv_lhs simp_rw add_smul, congr rw rcases simp refine rw simp rintro refine rw exact


induction of_isQF all refine simp exact ex unfold rw refine simp refine rintro exact by_cases obtain exact inhabit exact


revert induction of_isQF intro rw exact all intro unfold rw refine simp exact ex intro refine simp


induction falsum equal rel imp intros rw all intros rw exact


induction falsum of_isAtomic induction equal simp rel simp exact imp


induction of_isQF all simp refine rw exact


induction of_isQF ex simp refine rw exact


rw refine ext simp refine intros simp congr rcases


classical constructor simp rintro let refine ext simp exact rintro exact


obtain refine ext simp constructor rintro exact rintro exact


classical cases cases have have have refine simp refine simp refine simp constructor rintro refine ext rw simp rintro refine ext simp rw


cases cases refine obtain obtain have apply rw exact


obtain refine ext rw generalize_proofs change have rw simp exact


let let lift intro simp have intro rcases use simp rfl exact


FirstOrder.Language.DirectLimit.cg

refine exact rw simp_rw rw intro let refine rw trivial simp


have simp intro let have rintro rw rcases simpa exact


classical rw have f.map_formula simp rw refine erw


suffices intro exact refine exact intros simp intros simp erw intro simp intro simp refine rw exact contrapose rintro obtain htv rw exact refine rw


suffices induction nil cons intro induction var rw have listDecode induction nil cons simp getElem_fin, refine simp simp


refine rw refine rw refine refine grw lift_lift, rw refine rw exact rw refine cases rfl rw refine rintro simp rw simp simp simp rw


suffices induction nil cons rintro induction falsum equal intro rw simp simp intro rw have l)) some intro simp length_append, refine rw simp simp rw swap exact rw swap intro obtain rw simp refine obtain rw exact rw rw imp intro simp rw simp getElem_cons_succ, all intro simp rw simp drop_succ_cons,


rw constructor rintro obtain exact rintro exact


rcases rw refine have refine rw intro have rw exact


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


let let have intro apply intro exact have exact


classical refine constructor rintro use exact simp rintro refine rw exact


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


obtain simp simp_rw have intro obtain replace exact choose let let refine dsimp exact have refine exact refine have obtain refine rcases dsimp dsimp


constructor rintro refine age.jointEmbedding rintro obtain exact


let let let use change ext have simp simp apply ext simp


constructor intro let have let refine subset_closure.trans ext simp intro let use simp rw ext rfl


rintro obtain h let refine ext apply have simp simp erw simp erw simp


intro let have have rw exact haveI let hN.ultrahomogeneous.extend_embedding refine ext simp


let have obtain rw exact let cod toEquiv exact


letI refine have refine rw have refine rw


classical rw intro letI letI have have have have have have obtain m let convert simp g) use ext refine simp


constructor intro rcases cases exact rintro


let have intro ext let cases apply simp exact have exact


refine obtain refine simp ext rw simp coe_subtype, obtain refine subset_closure.trans rw simp


rcases have have let let let have intro have exact have exact


rcases rcases have have have have let let let have intro have exact have intro have exact have have refine convert rw apply


haveI rw letI have refine rw refine rw exact h.some.injective exact


obtain refine haveI rw refine rw refine rw


classical refine rw intro rw obtain exact hs exact


obtain have rw exact refine lift_inj.1 simp


rw refine contrapose rw refine is_model rw exact


refine letI have rw have let exact letI have exact


simp rw contrapose letI constructor intro simpa h simp exact intro exact


rcases simp rw refine simp exact simp intro rw exact


ext simp refine cases inl inr have rw contradiction


constructor intro refine intro rw rintro refine intro obtain by_cases left exact right exact


induction var cases cases simp rw simp rfl obtain simp rw exact


simp relabelEquiv_symm_apply] refine congr rcases


rw induction falsum equal rel imp have simp refine simp refine split_ifs simp refine simp split_ifs


induction falsum equal simp rw simp rel simp congr rw simp imp simp rw all simp refine rw


refine realize_mapTermRel_id erw rcongr obtain simp exact


induction falsum equal rel simp rfl imp all


induction zero succ simp constructor rintro exact rintro rw exact


let rw simp refine exact intro rw congr funext exact


induction falsum equal rel imp rw all rw refine have simp rw simp congr rcases simp refine simp simp rw simp exact


induction falsum equal rel simp exact imp all rw constructor intro have rw exact intro have rw exact


rw simp_rw simp forall_exists_index, refine rintro refine contrapose have simp exact rintro simpa


simp refine contrapose have simp exact rintro simp exact


simp conv_lhs rw gcongr rw refine rcases rfl rw exact


obtain rw rw refine have rw rw refine le_antisymm rw refine rw exact rw aleph0_le_lift, refine rw refine rw refine rw exact


let simp refine simp change rw refine rintro exact


refine suffices refine simp_rw have refine


refine have rw intro cases exact intro simp rw exact


revert induction falsum equal rel intros simp rw simp imp all


rw intro simp obtain cases inl refine rwa inr refine rwa


rw refine completeTheory.isMaximal rintro exact


have ext simp simp_rw refine rintro exact


letI induction falsum equal have funext simp erw exact rel have funext simp erw conv_lhs apply imp simp rw simp apply φ.Realize exact have refine simp simp simp simp refine contrapose refine exact rw exact


rw rintro rw simp apply rw norm_num all_goals rw norm_num


have contrapose rw have have have rw assumption_mod_cast simp have rw assumption_mod_cast simp have rw assumption_mod_cast simp calc


have contrapose rw have have rw assumption_mod_cast simp have rw assumption_mod_cast simp calc


have contrapose rw have rw assumption_mod_cast simp calc


have replace conv fin_cases exact have replace conv fin_cases exact have replace conv fin_cases exact exact exact


have have rw refine filter_upwards rw refine rwa


obtain obtain have filter_upwards rw rw exact have rw exact ae_restrict_of_ae_restrict_of_subset have have have have le_of_lt rw have h_locint have trans_iterate_Ico h_locint have h_locint exact rw exact


rw have have obtain rw integralmulsum have have have have simp_rw have rw exact sum_congr mod_cast rw integral_interval_sub_left integralmulsum integralmulsum ring rw exact rw exact rw exact rw exact exact


by_cases have have simp have have rw exact rw nth_rewrite rw simp grind


refine by_cases have refine refine refine exact rw exact


have refine refine exact refine rw exact


have filter_upwards rw have refine exact refine rw exact


obtain let refine cases zero succ rw calc exact refine exact grw simp unfold grw rw exact


by_cases grind apply rw carmichael_eq_exponent exponent_eq_of_mulEquiv exact have have exact


by_cases grind refine have rw mul_one] have have exact let rw exact


ext rw by_cases simp have rw simp intro have simp


classical induction empty insert ih rw rw exact


ArithmeticFunction.IsMultiplicative.mul

refine simp intro rw symm apply rintro simp rcases simp constructor ring rw exact simp rintro ext trans rw rw rw trans rw rw rw trans rw rw rw mul_one] trans rw rw rw simp rintro use rw gcd_mul_gcd_of_coprime_of_mul_eq_mul rw simp rw simp rintro rw hg.map_mul_of_coprime ring


constructor simp ext by_cases rw rw exact


by_cases simp by_cases simp have have have iterate rw rw apply intro rcases simp factorization_gcd apply apply rw apply simp


by_cases aesop constructor intro rw have have lia simp


refine cases zero succ rcases rw apply rw


by_cases cases induction zero succ rw ring


simp trans refine simp rw simp_rw rw exact


rw refine simp congr ext simp intro constructor intro grw intro grw simp


ext induction zero one prime_pow rw simp coprime hb rw exact


let let trans rw apply intro cases zero succ rw simp rw trans constructor rw apply intro cases zero succ simp rw rw


refine refine dsimp rw intro rw dsimp rw intro rw


constructor intro let intro suffices rw intro rw rw apply intro intro let intro suffices rw intro rw apply intro


simp rw have apply simp intro have rw rintro exact rw rw moebius_mul_coe_zeta] rcases


induction zero succ rw refine let have rw rw rw


cases zero succ n suffices rw_mod_cast ring simp_rw refine congr have simp rw_mod_cast


ext cases zero succ rw suffices simpa apply rw convert apply simp_rw rintro have simp


let suffices rcases apply specialize split_ifs simpa have rw suffices simpa congr


cases zero succ cases zero succ n suffices simp choose_zero_right, ring have simp_rw refine congr funext rw simp bernoulli'_one, ring


cases zero succ n rw have have have simp have rw apply convert refine obtain simp simp norm_num


ext cases zero succ n simp coeff_exp, and_false, cases zero succ rw have have simp rw refine rw rw simp


have have mk ext let bernoulli coeff simp apply intro simp have rw mul_assoc simp coeff_mk] rw tsub_add_eq_add_tsub ring exact simp have suffices mk rw rw simpa have simp use simp have have rw rw rw simp refine left congr simp rw refine simp


rw cases zero succ let let suffices have have have rw have simp_rw ring have sum_congr calc simp rw simp rw simpa


simp_rw simp simp_rw conv_lhs apply_congr skip conv apply_congr skip rw smul_eq_mul, simp_rw rw simp apply have intro rw have simp intro exact rw


rw simp_rw symm rw simp apply intro apply rw rw norm_cast


refine cases zero succ rw simp conv_lhs congr skip apply_congr skip rw simp_rw congr rw calc rw simp_rw simp


cases zero succ ext rw coeff_bernoulli, split_ifs subst simp grind cases inl inr grind simp


ext cases zero succ rw sum_range_succ] simp sub_self, have rw rw change rw mul_comm rw apply intro simp field_simp


let have div_pos have intro have have rw log_rpow have rw mul_div_left_comm, log_nonpos_iff have refine norm_num have apply apply exact convert ext simp rw norm_num1 rfl apply refine exact suffices obtain exact refine have rw norm_num1 have rw conv conv conv rw conv rw on_goal all_goals


rw simp refine gcongr have exact exact_mod_cast norm_num1 exact


refine apply grw intro rw rw obtain rw rw


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


have contrapose have centralBinom_le_of_no_bertrand_prime grw


rcases exact replace revert open run_tac for let evalTactic exact


apply simp convert have norm_cast linarith


apply convert simp have norm_cast linarith


trans refine simp le_rpow_inv_iff_of_pos, simp intro exact simp succ_le_iff, rintro rw refine rw refine exact exact simp_all simp rw refine simp congr ext simp refine simp_all grw apply have contrapose apply


by_cases rw bound rw apply simp_rw trans apply apply rw gcongr simp calc gcongr rw trans linarith exact apply norm_cast apply congr rw field


by_cases rw bound apply rw gcongr grw nth_rw rw norm_num linarith


conv refine integrableOn_mul_sum_Icc have have fun_prop


simp rw push_cast let trans refine split_ifs have simp simp rw intervalIntegral.integral_of_le have intervalIntegral.integral_congr simp grind intro have have fun_prop refine have have exact


have have rw grw rw norm_num gcongr all_goals apply linarith


trans apply filter_upwards apply rw grw positivity intro simp refine simp_rw apply conv apply


refine filter_upwards simp_rw calc rw exact refine rw exact refine calc θ


refine refine refine filter_upwards field


have filter_upwards rw have rw grw grind


have have rw exact have floor_nonneg.mpr refine rw apply gcongr rw exact intro have congr_arg rw have rw rwa


haveI induction zero intro refine simp rintro succ intro let obtain obtain h.exists_partition obtain have refine simpa have simp_rw obtain refine exact exact


set have simpa lt_of_le_of_lt obtain use ext by_cases rw apply exact


have rintro specialize rw exact set have simpa lt_of_le_of_lt obtain use refine by_cases refine exact lt_of_le_of_lt rw rw have have by_cases exact have rwa have rw convert


have rw exact have have have have assumption_mod_cast by_cases obtain exists_eq_polynomial refine rwa obtain exists_approx_polynomial_aux use by_cases rwa have suffices rwa cardPowDegree_nonzero log_rpow apply swap convert rw rw grw


have by_cases rwa by_cases rwa by_cases rwa rw refine rw have simp refine rw degree_eq_natDegree convert exact


have rw exact induction zero succ have intro simp_rw exact obtain ih rsuffices refine refine simpa rw exact rw exact rw exact obtain by_contra obtain exists_approx_polynomial revert refine exact rw have contradiction rw have contradiction rw rw have contradiction by_cases obtain refine apply rw exact refine have contradiction


obtain by_contra obtain apply apply ext simp simp apply refine refine exact


conv_lhs rw simp convert rw intro apply exact


obtain have set have intro exact have rw apply simp rintro exact have apply simp apply exact exact exact


obtain use rintro apply obtain exact refine intro contrapose exact


simp constructor rintro refine rintro simp rintro refine rw exact


have set have have have have rw mul_inv_cancel₀, try exact linarith set let have let let have have intro rw have intro rw simp refine rw obtain have let set refine exact have simp smul_sub] refine ring rw refine apply congr simp_rw if_true] exact


obtain obtain refine refine refine lt_of_le_of_lt rw mul_comm


set have obtain suffices obtain refine rw rintro rw exact rw exact rw apply swap rw apply rw exact rw intro rw obtain apply simp rw refine exact


ClassGroup.fintypeOfAdmissibleOfFinite

letI letI letI choose have apply simp apply obtain let rw exact exact let have exact


IsCyclotomicExtension.trans

refine intro rcases obtain refine exact exact refine adjoin_induction let have rw refine obtain exact


have refine refine obtain exact refine have exact


have refine rintro left right rintro exact exact refine replace rwa


refine obtain refine rwa convert rw norm_cast


by_cases rwa rw refine obtain exact use rw exact


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


refine exact rw refine simp obtain obtain exact exact


by_cases exact rw empty_union, refine refine simpa refine simp


ext have induction mem obtain obtain have obtain simp algebraMap add mul


IsCyclotomicExtension.isMulCommutative

refine obtain use simp have obtain obtain simp


classical rw refine simp have rw exact simp exact


IsCyclotomicExtension.finite

rw induction empty refine simp by_cases have rw exact have union_left have have rw let have exact exact


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


refine suffices obtain exact refine refine rw exact simp simpa


have let refine rintro let have ext simp constructor rintro rintro rw obtain induction mem obtain apply use rw congr apply_fun simpa algebraMap convert exact add convert exact mul convert exact rw rintro have obtain obtain exact


IsCyclotomicExtension.isGalois

rw use obtain rw intro rw obtain rw induction mem obtain apply use rw algebraMap convert exact add rw exact mul rw exact inv rw exact


CyclotomicField.isCyclotomicExtension

have letI have obtain rw refine simp exact rw exact


refine have rw congr simp forall_exists_index, exact


rw simp suffices apply refine obtain exact exact simpa


have constructor rintro exact obtain replace obtain have simpa adjoin_le


obtain obtain replace replace have rw hζ₁.adjoin_pair_eq have exact


obtain obtain have have have have simp rw simp rw conv_lhs rwa


modularCyclotomicCharacter.id

refine have obtain have simp have obtain simp


ext apply apply simpa modularCyclotomicCharacter.toFun_spec


cyclotomicCharacter.continuous

by_cases simp exact haveI choose refine apply rw intro obtain obtain exact refine exact intro refine dsimp rw map_one, apply intro obtain rw exact exact


haveI haveI haveI rw totient_prime_pow have rintro exact congr rcases rcases rw rw cases simp simp_rw have obtain rw mul_right_comm, refine rw exact have rw derivative_one, replace simp aeval_X_pow] replace have by_cases exact exact rw succ_eq_add_one, rw pow_mul, have rw replace simp have rw exact


rcases simp traceMatrix] have rw minpoly.eq_X_sub_C_of_algebraMap_inj simp rw simp by_cases obtain rw exact nth_rw replace rw subst rw have rw minpoly.eq_X_sub_C_of_algebraMap_inj exact rcases rw simp_rw convert_to congr ext simp suffices rw convert rw simp traceForm_apply, rw exact


have rw infer_instance have convert rw rw


intro apply_fun simp generalize_proofs have have generalize_proofs suffices apply apply exact rw refine rw congr rw convert conv rw


rcases simp rcases simp let let have haveI convert rw simpa


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


have convert rw simp simp obtain obtain have have rw obtain replace obtain exact


haveI by_cases rw rw replace rw hζ.minpoly_eq_cyclotomic_of_irreducible hζ.minpoly_eq_cyclotomic_of_irreducible exact


haveI let obtain apply letI letI rw conv_lhs congr rfl ext rw rw have rw refine simp have rw


haveI rw hζ.minpoly_eq_cyclotomic_of_irreducible simp


have rw have simp ring replace rw totient_prime_pow simp


have nth_rw exact replace replace obtain simpa


by_cases have rw exact replace rw nth_rw replace rw exact simp obtain rw simp exact


Dioph.DiophList.forall

suffices from let induction nil cons obtain exact let simpa rw exact refine rw funext exact rwa funext refine rwa funext


let have have conv let by_cases obtain have have have refine exact refine rw refine simpa have have have mem_Ico.mpr obtain obtain rcases exacts refine sub_le_iff_le_add.mpr convert_to congr exact


obtain have have convert exact refine rw refine rwa div_mul_cancel₀


have obtain have obtain have have refine lt_of_le_of_lt hm.trans lt_of_lt_of_le rw exact


refine obtain exists_min_image obtain exact


have replace rw conv_lhs rwa constructor rcases exact have rw div_mul_comm, refine norm_cast rw exact obtain abs_sub_lt_iff.mp rw rw norm_cast exact


let set have intro simp rw have intro simp obtain obtain simp_rw refine simp exact refine exact


have obtain obtain refine rw have refine have rw norm_cast rw rintro cases norm_cast linarith


obtain obtain have rw mul_assoc, have refine rw replace rw exact mod_cast h.trans_le have refine replace rw add_comm have flip flip rw exact have refine rw simp rcases linarith


obtain have set have rw replace obtain obtain have replace have rwa have replace have rw mul_lt_mul_iff_right₀ refine rw exact calc gcongr


refine rw exact obtain have have have rw rwa lt_inv_comm₀


induction h rcases replace simp exact rw obtain rcases use rw convert replace have rw exact rcases rw exact have rw inv_lt_comm₀ refine rw convert rw norm_num use simp obtain have have have obtain use rw cast_natCast,


refine exact rw simpa obtain replace have rw rw exact


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


have contrapose exact suffices have contrapose refine exact obtain suffices obtain refine rw have apply rw changeLevel_trans


suffices rw rsuffices have simp rw ext1 simpa rw have rwa


obtain simp constructor rintro simp lia rintro rw simpa