ext simp exists_eq_left] constructor rintro rw exact rintro exact


cases rw simp classical rw intro apply rw contrapose apply rw gcongr have simp apply


refine intro refine rw have simpa by_contra simp contradiction exact


rw simp apply intro constructor rcases rw exact rcases rw simp


by_cases simp ext constructor rw rintro rw refine rw exact rw rintro exact


ext rw simp constructor intro grw simp lia intro exact


induction nat rcases iterate simp_rw norm_cast simpa neg rcases simp simp_rw show ring1


induction nat rcases simp norm_cast simpa neg


induction nat rcases simp norm_cast simpa neg rcases simp simp_rw neg_mul, ring1


induction zero one two three four simp repeat


induction empty rw simp exact insert rw split_ifs constructor simp equivProdNatFactoredNumbers_apply', refine apply have rw conv enter rw have apply ih.2 apply rwa


obtain simp_rw refine have rwa tsum_eq_tsum_diff_singleton


let change rw intro obtain refine have prod_mulIndicator_eq_prod_filter rw exact


EulerProduct.eulerProduct

have let have prod_mulIndicator_eq_prod_filter simpa


have have refine simp exact have intro simp refine exact exact


have have have prod_mulIndicator_eq_prod_filter have simpa


rw have rw tprod_subtype rotate_left exact exact congr simp one_mul, by_cases simp simp by_cases simp have simp simp have rw refine rw apply_fun simp have have exact


tfae_have h, obtain refine push_cast simp obtain refine push_cast simp exact refine push_cast simp refine push_cast simp refine push_cast simp refine push_cast simp exact refine push_cast simp tfae_have h, rw refine h have refine push_cast simp div_self tfae_have h, tfae_finish


tfae_have apply simp intro rw simp tfae_have rw apply intro by_cases subst simp rw rcases tfae_finish


intro let obtain obtain obtain simp rw refine rw obtain refine rw hB,


rcases simp refine rintro simp simp zero_ne_one] rw refine simp rcases simp


delta constructor intro constructor exact constructor exact have linear_combination intro constructor exact constructor exact apply linear_combination


classical let have use rw use let have rcases use intro rw apply use


apply by_contra obtain obtain obtain have rw apply ring obtain have apply rw exact exact


obtain rcases rcases exfalso have rw revert decide exact exact


obtain rcases use exfalso exact use exact


have delta linear_combination h.1.2.2 have have rw decide obtain have delta linear_combination have apply apply rw exact have have apply rintro lia obtain have rw exact have apply rw exact obtain have apply linear_combination have have obtain have by_contra have rw apply replace rw rw obtain have by_contra rw have rw exact have exact replace obtain have rw rw obtain have have have grind have have grind have apply rw apply rw apply exact have apply exact apply


have have set have calc abc_dr.natDegree set apply calc a.natDegree rw rw rw


Polynomial.abc

set have rw rw convert rw have have rw rw convert rw have have rw simpa have have have have rw rw rw exact by_cases right rw obtain obtain exact left refine rw apply rw apply apply


have have have have have have have have have exact have exact have exact have classical rcases simp_rw radical_mul_of_isUnit_left radical_pow natDegree_C, radical_mul obtain have have have rw exfalso exact rw mul_eq_zero_iff_left derivative_pow_eq_zero exact


rcases obtain have apply intro rw exact rw exact natDegree_C generalize induction hz hi obtain obtain obtain obtain set suffices by_contra apply apply rwa have have rw grw lia rw simp_rw rwa


have have have refine apply rw rw apply rw rw apply


Polynomial.flt

have rw have have simp_rw apply flt_catalan heq have rw exact


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


simp_rw apply simp_rw rcases rcases rw decide


have refine rw refine convert rw by_contra by_cases apply rw exact refine rw rw ring


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


rw refine by_cases swap exact rw rw rcases refine simp rw refine simp rw refine rw simp


obtain rcases rcases exfalso replace refine symm calc left exact right exact exfalso replace refine symm calc


have suffices obtain refine rw convert simp have rw norm_cast lia


rcases exact refine simp refine rw mul_one] refine rw exact rw mul_one]


obtain exact b c u ha hb hc coprime hcdvd hab


intro rcases refine rw show simp apply_fun rw show rw ring


suffices rw rw have rw convert symm calc


have replace rw apply apply have rw show simp rwa


suffices rw λ have rw show simp convert ring simp rw ring


rw add_assoc, apply mul_right_cancel₀ mul_ne_zero simp rw congrm have calc ring simp divp_mul_eq_mul_divp, ring


have have apply rcases rcases rcases replace replace rcases rcases refine rw formula2] ring refine rw formula2] ring refine rw formula2] ring refine rw formula2] ring


fermatLastTheoremThree

classical let let have apply intro let b c u ha hb hc coprime hcdvd obtain obtain obtain linarith


rcases simpa have apply simp rintro exact simp intro constructor rw exact rw exact have rw rintro apply rw calc


induction zero succ hn rw sq_sub_sq] ring_nf lia


wlog simpa let have have fermatNumber_eq_prod_add_two refine exact


have have have rw exact_mod_cast have intro rw exact have apply rw exact rw simpa


have have have obtain obtain rw simp obtain suffices rw rw rwa


have have have have have contrapose let rw exact subst refine have let rw exact


by_cases apply rintro apply replace rw refine lia rw simp


have rw constructor intro apply exact intro exact


unfold set set have have have have have have have lia have have have have have have refine have apply_fun rw apply_fun nth_rw rw rw exact have rw have have have have have have exact have obtain have obtain have have rwa have suffices rwa have haveI rw exact have have have rwa have rw exact have use have congr_arg simpa obtain have simpa exact


unfold set set rw have suffices have have linarith rwa rw conv_rhs rw suffices apply exact have exact suffices rw have have have exact


by_cases have obtain have have have have have have have have have have use constructor exact exact le_trans have rw use have exact


simp_rw have constructor push_neg intro apply simp zify rw rw ring intro dsimp contrapose let have suffices obtain obtain exact refine rw exact


by_cases refine have have let refine obtain rw set set rw refine add_mem obtain dvd_mul_of_dvd_right dvd convert simp_rw smul_eq_mul, congr split_ifs rw rw mul_neg rw exact


let have intro rw congr refine refine simp constructor let exact let refine intro


rw conv simp have rw simp simp exact exact rw


rcases simp χ.sum_eq_zero_of_ne_one refine rw


simp conv enter rw simp_rw rw classical simp_rw rw simp


have intro rw exact not_isUnit_prime_of_dvd_card rw apply rw


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


have obtain let have have have have have rw rw change exact let primitiveZModChar let let have rw refine rw decide rw decide let have have isQuadratic_χ₈.comp have have rw show show show simp linear_combination have rw linear_combination have rw convert_to rw apply simpa


by_cases simp have simp_rw rw gcongr simp calc simp_rw exact sub_inv_antitoneOn_Icc_right convert norm_num simp convert rw simp


by_cases simp calc gcongr apply norm_cast exact


refine rw add_sub_cancel_right, div_self refine positivity positivity simp


refine rcases simp simp_rw rw refine positivity simp simp


have rcases simp simp gcongr linarith apply exact


suffices simpa suffices apply filter_upwards simp exact


firstly, which let suffices rwa have have simp have refine exact ne_of_gt have rw apply filter_upwards have induction zero succ rw push_cast ring suffices rw have refine hc.slope_le_deriv rw have refine rw h_rec apply apply filter_upwards rw exact apply filter_upwards rw exact


have differentiableAt_Gamma have refine calc deriv rw add_neg_cancel, apply simp exact rw rw apply exact exact rw simp exact exact congr change rw rw fun_prop apply simp fun_prop congr apply have two_pos norm_num simp_rw apply exact


let have have refine rw neg_div] have simp rwa mul_one_div,


let let have rw have have have refine rw have have rwa exact refine simp rw mul_neg, ofReal_log ofReal_log norm_num


induction zero succ rcases simp rw have rw exact rw ih, exact


have intro rw exact calc term simp_rw simp_rw rw simp_rw exact exact congr rw all_goals congr refine rw exact rw simp_rw refine all_goals congr simp


rw change simp_rw refine have refine simp_rw push_cast abel


have intro rw exact calc term refine rw rpow_neg rw apply refine exact_mod_cast linarith have rw congr rw rpow_neg rw rpow_neg


simp conv rw congr induction zero succ rw ring_nf simp_rw congr induction zero succ simp_rw congr ring_nf


apply rw change simp_rw apply rw simp_rw refine refine exact rw apply exact_mod_cast apply change rw refine exact intro positivity intro dsimp transitivity gcongr linarith apply rw norm_cast all_goals


simp apply exact intro rw filter_upwards have rw gcongr exact_mod_cast exact linarith rw exact_mod_cast rw filter_upwards refine exact exact


refine rw simp_rw refine exact exact have gcongr exact assumption exact rw refine all_goals


suffices apply filter_upwards simp rw congr rw norm_cast suffices have rw simpa apply filter_upwards apply rw apply have exact


let suffices obtain suffices refine exact filter_upwards rw exact refine filter_upwards refine fun_prop rwa refine filter_upwards rw tauto simp_rw apply simp_rw apply refine filter_upwards field exact


have rw have h.div rw refine have apply simp rw filter_upwards rw


refine obtain exact exact one_le_finprod le_max_right


have suffices convert have have refine rcases rw exact exact exact


rcases rw have have simp rw product_formula


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


rcases simp rcases rw simp have simp rw rw simp


rcases cases have have simp simp norm_cast exact have simp


rw conv enter rw rw conv rw sum_sdiff_eq_sub congr rw


classical rw have intro rw simp simpa calc rw


classical rw conv rw have refine sum_bij simp rw right_eq_add, exact simp rw exact simp rw simp simp rw simp rw exact


classical rw conv enter rw mul_one] rw have intro simp exact simp_rw conv simp_rw rw add_zero]


obtain let let let let have apply rw have rw exact have have have have intro simp exact have apply_fun simp rw jacobiSum_mul_nontrivial gaussSum_mul_gaussSum_eq_card


rcases exact rcases exact obtain obtain rewrite exact


obtain rw obtain by_cases rw refine rw ring refine rw refine rw classical rw have have have refine refine exact exact conv rw ring


induction base succ specialize have have rw apply_fun rw rw


apply rw quotEquivOfEq_symm, congr convert apply simp


ext by_cases swap rw simp rintro exact have rw refine this.trans generalize have rw subst rw exact exact exact exact exact rwa


classical have normalize normalizedFactors suffices obtain have prod_normalizedFactors rwa rw rw exact rw use rw use refine apply rw exact


dsimp rw dsimp simp refine le_antisymm rw obtain obtain rw rw exact


have simp_rw obtain use filter_upwards have have specialize simp_rw rw le_div_iff₀ convert congr rw simp simp_rw norm_of_nonneg field


simp_rw refine rw simp_rw apply refine filter_upwards apply rw exact


rw have simp_rw one_div] have rw have rw rw refine simp_rw rw have field_simp


have refine refine have fun_prop refine obtain refine rw exact obtain refine rw exact


refine rcases simpa simp rcases apply apply simpa simp


WeakFEPair.hasMellin

have let mellinConvergent_of_isBigO_rpow refine have have have simp_rw exact


simp_rw refine rw apply rw refine have fun_prop refine refine match_scalars field


LSeriesSummable.congr'

rw refine have rw obtain refine rw simp exact


replace use by_contra have rw div_le_iff₀ exact


obtain have have simp_rw have refine simpa simp refine simp ring_nf refine rcases simpa have simp_rw simpa


obtain obtain let have have refine rcases refine have gcongr rw have refine refine exact


cases coe top bot refine cases bot coe top


have ext simp have simp refine filter_upwards


ext rcases refine have ext simp have rintro rcases simp rw


rcases simp simp_rw exact simpa non-private


obtain obtain let have have have have norm_term_le_of_re_le_re have simp_rw refine simpa


apply exact refine filter_upwards simp refine simpa


induction zero succ ih have have simp_rw rw simp


ext rcases simp_rw rcases simp have simp_all


refine refine simp split_ifs simp simp all_goals


have have refine refine exact refine refine refine have fun_prop refine exact simpa


rcases have have continuous_finset_prod have fun_prop exact congrFun s exact


have refine rw rw conv refine refine exact continuous_finset_prod have fun_prop


classical rcases simp have refine rwa let rw calc completedLFunction simp split_ifs rw completedLFunction_one_sub_even replace rw neg_neg] congr rw rw ring rw


rw refine continuousWithinAt_compl_self.mp simpa


simp_rw have refine rcases exact rw exact


rw rw generalize generalize generalize ring_nf


have convert push_cast ring rw hurwitzZetaOdd_neg, rw generalize generalize generalize ring_nf rw ring_nf


rcases rw exact induction rw have push_cast rw have have rw ring have rw have rw ring rw neg_add_cancel,


haveI simp_rw split_ifs obtain simpa suffices contrapose let exact


rw have rw simp_rw add_sub_assoc, refine push_cast rw congr


induction obtain refine filter_upwards simp


induction obtain refine filter_upwards simp apply intro rw exact


rw congr change completedHurwitzZetaEven₀ completedHurwitzZetaEven₀ rw change push_cast rw


have completedHurwitzZetaEven completedHurwitzZetaEven₀ simp_rw abel rw refine apply


let have refine split_ifs simp rw rw congr refine rwa refine apply intro simp norm_div, norm_of_nonneg simp


have have rw refine split_ifs simp simp show


have refine split_ifs rw rw rw completedHurwitzZetaEven mellin simp_rw refine rwa refine simp_rw apply rwa rw


have have refine filter_upwards rw rcases refine filter_upwards simp simp_rw have refine simp refine rw exact exact


suffices apply filter_upwards rw simp_rw refine simp_rw conv exact


rcases exact differentiableAt_update_of_residue apply filter_upwards rw


rw have rw simpa rw hurwitzZetaEven_def_of_ne_or_ne generalize ring_nf


simp generalize generalize simp_rw refine congr_arg rw congrm


rcases rw have rw rw div_mul_div_comm, mul_comm congr rw div_mul_eq_mul_div jacobiTheta₂'_neg_left, congr rw


induction a suffices simp_rw refine fun_prop have apply exact exact continuousAt_const.mul


induction a suffices simp_rw apply have fun_prop


rcases rw induction a have rw neg_mul, have rw have simp have rw generalize rw ofReal_ofNat, eq_div_iff eq_div_iff


rw have have refine rw jacobiTheta₂_term, push_cast simp congrm simp ring_nf


have simp not_false_eq_true] rw refine rw ofReal_mul, congrm simp exact simp


induction obtain refine filter_upwards simpa abs_of_nonneg


induction obtain refine filter_upwards rw apply exact intro rw mul_assoc, exact


let have simp_rw norm_div, have refine rw have simp_rw apply apply refine simp ring


have simp_rw refine rw rcases simp simp_rw simp congr rw congr


let let have refine simp have simp_rw apply rwa have refine simp


refine suffices simp intro rw rcases simp rw


rw refine rw refine norm_cast ring_nf push_cast congr have rw apply norm_cast lia


have rw refine exact have have refine simp rw mul_assoc, congr rw sub_zero mul_neg_one,


have rw refine positivity have refine simp rw sinZeta_two_mul_nat_add_one mul_div_assoc] congr rw ofReal_div, ofReal_one,


obtain lift let have have rcases simp exact simp have refine simpa have intro rw congr ext1 rcases simp simp conv refine tendsto_const_nhds.add have refine by_cases simp simp have rcases have have have have simp conv enter rw conv exact simp rw refine filter_upwards rcases simp rw have gcongr assumption simp


by_cases simpa simp refine let have have suffices have have have simp rw obtain exact intro induction ind suffices replace simp exact cases zero succ simp


by_cases simpa simp refine convert refine ext simp simp simpa


rw obtain obtain obtain lift lift refine have refine exact have refine exact rw


have convert have rcases simp rw simp_rw ring_nf have rcases simp rw simpa


have let have simp split_ifs exact have simp_rw convert rcases refine simp split_ifs simp positivity have rw


have simp_rw convert rw rw ring_nf all_goals convert rw


have have have have split_ifs conv convert rcases rw rw conv_rhs field convert rcases rw rw div_right_comm,


simp hp.ne_zero, rcases refine simp refine simp simp split_ifs exacts


rcases simp simpa zetaMul_prime_pow_nonneg


rw have simp congr simp_rw exact exact exact


intro rcases exact refine filter_upwards exact let let have ext1 rcases simp simp mul_div_cancel₀ rw apply simpa exact


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


by_cases have have rw exact have rw norm_cpow_eq_rpow_re_of_pos simp rw convert simp congr rw mul_left_comm] rw show simp add_zero,


have simpa mul_le_of_le_one_left refine simp


have have have have have have have rw simp rw simpa ofReal_one]


have have convert simp simpa exact exact


intro have refine simp have have rcases rw rw mul_one] have eventually_nhdsWithin_of_forall have simp replace simp exact isLittleO_irrefl


rw refine rw split exact refine induction zero succ rw refine simp


have have have have refine have simpa exact_mod_cast


have prodNatEquiv.symm.multipliable_iff.mp simpa simp refine


refine unfold have convert ext1 by_cases simp simp zero_div,


have have suffices refine simp positivity conv refine dsimp exact dsimp conv refine positivity rw gcongr rw inv_le_inv₀ exact


have have refine split_ifs refine have refine swap simp implies_true, have refine ext1 simp congr rw refine have have ext1 simp refine exact simp true_and, rw


rw simp refine refine simp tauto simp refine replace refine simp rcases simp not_false_eq_true] exact


intro replace simp rw mul_add] congrm have classical rw simp congrm have rw add_div, conv_lhs rw


rw simp congr rw re_tsum push_cast refine rcases simp simp rw


have refine simp ofReal_sub, simp_rw eqOn_LFunctionResidueClassAux refine split_ifs simp rfl have continuous_re.continuousOn.comp continuous_ofReal.continuousOn obtain replace hC refine rw exact


intro have convert simp let have refine rcases simp refine conv_lhs exact exact obtain have have rcases have rw exact obtain refine simpa and_true] rw exact exact


have rw have norm_cast simp tsum_pnat_eq_tsum_succ intro simp exact


have have rw exact have have have filter_upwards rw simp_rw refine refine exact refine exact refine exact rwa


have simp_rw refine refine exact have simp_rw refine have simpa refine refine exact rwa


have refine exact refine filter_upwards simpa mul_le_mul_of_nonneg_right exact


have have rw calc refine exact exact have rw exact rw refine mul_le_mul_of_nonneg_left exact exact rw field


obtain let let have refine exact refine filter_upwards rw have have refine simpa have have refine isCompact_Icc).mono_set exact have rw show exact let have refine exact gcongr exact calc l rw mul_assoc] exact rw congr exact exact congr refine replace rw rw exact congr refine replace rw rw exact exact rw gcongr gcongr exact


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


rw congr have mem_Icc.mpr rw congr calc simp mul_div_cancel_left₀ rw simp simp


rw congr rw div_mul_eq_mul_div, have conv_rhs rw


let let have by_cases simpa simp let let have tauto have refine refine simp have refine refine rwa have by_cases simpa simpa have have have refine filter_upwards


have by_cases rw simp rw simp rw simp congr congr rw


rw have rcases rcases simp rw rw simp generalize simp_rw congr rw conv_rhs simp_rw


simp refine refine exact exact refine exact exact


have have suffices simp suffices simpa div_left_inj simp map_neg, exact


suffices simp suffices have simpa calc simp congrm exact simp ring


let let let have have have have let have convert ext by_cases simp have refine refine exacts have refine apply apply exact ht.2.imp_right have have eventually_of_mem simpa exact


let let have have apply rw exact have have rw exact


simp_rw rcases obtain refine exact rw ext1 rw


AddChar.FiniteField.primitiveChar

let haveI let have rcases exact rw exact let letI let have obtain rw exact exact


by_cases subst simp have have rw simp_rw rw rwa


apply simp constructor rintro rintro have rintro simp refine


rcases by_cases rw norm_cast have subst rw revert push_cast generalize tauto simp convert exact


have intro rw simp by_contra rcases rw exact rw exact


have have lt_of_le_of_lt have not_lt_of_ge have intro simp have intro refine apply simp inv_eq_zero, apply rw split_ifs rw rw if_pos exact


have card_equiv simp and_left_comm]) have apply have have apply_fun rw simp have have simp tauto rw simp


have rintro rw exact have rw obtain exact


let map_one map_mul have refine have rw refine have rw


rcases rw have rcases have nth_rw rw pow_left, congr congr simp_rw rw rw simp apply rcases rw use


induction ind unfold split rw simp split rw simp by_cases split subst split suffices refine rwa rw simp rw by_cases


ext induction ind unfold split_ifs rw refine refine refine exact dsimp rw obtain rw mod_left rw rw rw exact exact


by_cases rw by_cases rw have by_cases rw quadraticCharFun_eq_one_of_char_two rw quadraticCharFun_eq_pow_of_char_ne_two rcases simp have simp rcases


by_cases have simp rw by_cases simp have simp exact


by_cases simp set by_cases rw rcases rw have ext1 rw simp_rw mem_insert, exact norm_cast rw exact rw simp simpa


classical by_cases simp exact have rw χ₄_nat_eq_if_mod_four, lia


classical by_cases have simp lia have rw lia


classical by_cases have simp lia have rw χ₈'_nat_eq_if_mod_eight] lia


let have obtain refine simpa have rw exact


have have have have rw have have rw quadraticChar_sq_one quadraticChar_neg_one


rcases subst rw quadratic_reciprocity_one_mod_four


rw simp nth_rewrite nth_rewrite rw have exact


obtain by_cases simp letI letI obtain obtain obtain obtain simp obtain obtain simp refine simp exact refine intro dsimp exact convert refine ext simp


apply letI haveI obtain let have have exact


obtain replace induction base succ rw lia


dsimp rw constructor intro apply exact exact intro rw simp


have obtain rw have have rw ring have rw have rw refine norm_cast simp


dsimp rw replace obtain use replace dsimp rw replace dsimp have rw rw rw replace have exact


apply exact intro have congr_arg orderOf_dvd_iff_pow_eq_one.1 have haveI apply apply apply push_cast exact


set clear_value obtain have contrapose intro have have have exact


have set clear_value obtain dsimp rw have rw simp


have calc have induction zero rw simp succ rw have zify calc zify rw


rw induction zero succ rw clear induction zero succ


have obtain have rwa have rw refine replace exact


let p have simpa invFun p refine have rw exact left_inv right_inv rw norm_cast grind


have conv rw simp apply zify rw norm_cast rw have gcongr intro rw apply gcongr exact grind have apply rw grind exact


rcases simp have suffices simpa suffices intro exact


have rwa obtain have contrapose simp_all have obtain use rw apply exact


rintro by_contra set have refine calc n rw simpa simp rintro rw exact simp rintro rw prod_primeFactors_of_squarefree rintro rw


rintro let have convert rw simp refine ext


letI let let let have ext1 dsimp rw have ext1 rw dsimp rw rw have let suffices apply intro have rw ext dsimp fin_cases change rw change rw ofReal_im, simp have have convert rw rw exact


let have refine simp and_self_iff] refine let have simpa have cocompact_ℝ_to_cofinite_ℤ_matrix.comp have convert ext fin_cases simp map_apply, lcRow0Extend_apply, val_planeConformalMatrix, convert simp dotProduct, simp cons_val_fin_one, neg_sub] ring rfl


have have have subst rw replace have simp simp linear_combination


suffices exact have apply exact let let convert change lcRow0 exact


classical let have obtain obtain refine rw simpa exact exact exact


haveI let obtain refine intro have rw exact exact


have replace rcases use suffices ext fin_cases use suffices ext fin_cases simp


have replace refine conv_lhs simp add_zero,


obtain obtain refine have have rw simpa constructor contrapose refine rw exact change rw constructor contrapose refine rw cases contrapose refine rw cases


let let suffices rw replace rwa suffices rcases rw refine specialize linarith intro have gcongr have div_le_one_of_le₀ let calc rw ring


have intro by_contra let let have rw dsimp group let have replace have linarith have intro replace replace exact specialize rcases


ext constructor rintro exact rintro have apply contrapose simpa h2.trans_lt exact


rw constructor apply apply apply exact refine simp refine rw apply rw exact rw exact


constructor refine simpa comap_map_eq_self_of_injective


rw intro obtain suffices obtain have rw simp


Subgroup.IsArithmetic.inter

constructor constructor apply apply rw simp


refine rintro exact by_cases convert convert simp


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


obtain refine obtain specialize rw grw gcongr rw exact rw by_cases have zero_ne_one have refine rw simpa refine rw gcongr rw simp have nlinarith


let obtain rw exact simp have simp fun_prop have induction simp have γ.induction_on hf_infinity h⁻¹ have obtain exists_bound_of_invariant_of_isBigO refine simpa


conv refine apply rw simp_rw have simpa exact


obtain refine lift specialize have have rw rw refine generalize have lift rw norm_cast rw congr


let have have have obtain rw rw use filter_upwards hn rw intervalIntegral.integral_const_mul] simp refine let have have simp rw gcongr simp grw simp refine refine simp fun_prop exact exact simp


simp apply obtain simp_rw use filter_upwards refine rw exact


rw constructor intro simp intro ext rw fin_cases exacts


constructor intro have rw simp simpa intro simp exact


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


let let have simp let let refine obtain replace rw simpa use rw ext simp_rw refine rw simpa congr_fun₂ let have simp add_mul, conv_rhs simp rw inv_mul_cancel_left₀ have have simp_rw rwa refine rw ext simp_rw coe_one, zero_mul]


obtain refine simp_rw obtain obtain use simpa


constructor let suffices obtain rw suffices haveI simpa intro simpa


constructor rw constructor rw exact rw exact


obtain haveI obtain rw refine obtain exact


constructor rintro simpa rintro obtain refine suffices refine simp norm_num rw simp


rw constructor rintro obtain refine rw rintro refine rw


by_cases simp replace obtain rw refine simp rcases exact simpa


ext simp refine rintro refine ext fin_cases


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


ext have simp constructor rintro rw apply rwa simp mapGL_coe_matrix, refine ext fin_cases


have aesop have ext simpa simp_rw h3] simp


refine intro simp exact intro ext exact intro use simp constructor rw exact ext simp_all


simp have replace field_simp simp ring_nf simpa


intro simp apply simp zpow_neg, rw_mod_cast ring


ext simp have simpa have rw simp field_simp ring


have have rw simp rw refine rw apply simp


rw simp ring_nf rw grind apply grind apply grind simpa


rw have ext have rw tsum_zero_pnat_eq_tsum_nat field rw nth_rw refine exact


have rw apply grind simp rw apply simpa simpa


by_cases simp simp by_cases by_cases simp ring have have simp grind have have simp grind


set rw rw congr rw exact simpa grind exact


rw tsum_eq_of_summable_unconditional apply rw apply simp mul_inv_rev] nth_rw ring simpa simpa apply rw apply rw simpa apply rw exact have rw exact


have induction one mem simp rcases ext simp modular_S_smul] ring_nf aesop simpa mul ih rw grind inv have simp_rw nth_rw have simp rw


rcases apply fun_prop left exact simp apply


intro suffices convert exact refine exact isOpen_upperHalfPlaneSet


apply intro have ext ring_nf simp ring_nf


have have ext ring simpa isBigO_ofReal_right.mp simp convert ring


apply intro have let let have simp intro have simpa refine simpa have simp iteratedDerivWithin_cexp_aux c] rw gcongr convert rw


have iteratedDerivWithin rw iteratedDerivWithin_const_mul simp exact have simp_rw congr ext ring simp ofReal_eq_zero, congr ext have simp_rw simpa


rw tsum_int_eq_zero_add_two_mul_tsum_pnat nth_rewrite exact have simp_rw simp rw congr simp suffices simp_rw exact


have have simp_rw rw tsum_mul_tsum_of_summable_norm exact simp_rw rw exact summable_mul_of_summable_norm eisSummand simpa refine rcases simp have simpa


have set rw show show norm_cast simp grind


refine have simp not_false_eq_true, have simp not_false_eq_true,


have have rw rw gcongr rcases simpa simpa


rw simp refine suffices refine simp simp apply filter_upwards rw exact


rw have use filter_upwards apply le_trans simpa summand_bound_of_mem_verticalStrip simp aesop


have have mod_cast simp intro obtain refine simpa summand_bound_of_mem_verticalStrip


rw simp gcongr have have linear_combination


have refine simp_rw norm_eq_abs, gcongr rw rw refine rw apply apply simp_rw abs_pow, filter_upwards gcongr exact


split_ifs rw have apply filter_upwards exact refine simpa simp_rw have apply filter_upwards exact refine simpa


suffices rexp a let refine filter_upwards exact have simpa rcases exact simpa refine conv_rhs refine filter_upwards rw nlinarith simp_rw apply simpa


apply suffices funext intro rcases simp simp abs_neg,


obtain obtain obtain simp_rw simp_rw refine have filter_upwards rw ring refine exacts


obtain obtain obtain refine have filter_upwards exact refine exacts


let have refine rw have rw ring obtain rw have rw exact


suffices calc rw have intro simpa have simp_rw exact hasSum_geometric_of_lt_one have exact


simp_rw mul_comm refine rw refine rw exact


suffices apply apply apply refine simp_rw conv enter rw refine exact


refine refine simpa by_contra rcases suffices replace exact simp conv enter rw refine exact tendsto_atTop_add_const_right simp_rw rcases replace simp_rw refine refine simp apply exact revert simpa have replace simp_rw refine exact tendsto_exp_atTop.comp


constructor rw intro have refine have filter_upwards refine apply refine refine rw exact intro refine refine simp_rw refine refine exact


constructor rw refine have filter_upwards rw refine simp_rw norm_of_nonneg inv_mul_cancel₀ rw exact refine rw refine simp_rw


obtain obtain let have refine exact have have refine simpa let let have let have refine refine exact have simp_rw exact have refine simpa simpa hasFDerivAt_tsum_of_isPreconnected


let cont map_add map_smul simp have apply have simp add_zero, rw have rwa


obtain obtain let have refine let have simpa refine apply unfold fun_prop exact


rcases have rw exact rw unfold have simpa calc rw simp_rw congr field_simp ring_nf simp_rw ring_nf congr ring


rcases rw rw exact have rw exact have have simpa calc rw simp_rw cexp rw exact rw simp rw deriv_const_mul_field, ring_nf


have have simp_rw nth_rw simp refine rwa


refine exact simp simp rcases refine obtain exists_one_half_le_im_and_norm_le exact simpa hξ₂⟩


ext have simpa cuspFunction_eqOn_const_of_nonpos_wt


obtain convert have simpa obtain simpa simp exact


set have set calc petersson simp mul_zpow, ring rw ring rw


obtain obtain use apply simp_rw conv_rhs have refine refine tendsto_comap simpa


intro by_cases have simp convert ext simp have simp


rcases exact exact differentiableAt_comp_ofComplex


let have have rw conv simp_rw intervalIntegral.integral_const_mul] congr let have simp congr push_cast have grind simp_rw smul_eq_mul, field_simp


ext1 calc σ σ rw map_zpow₀] σ denom rw ring


ext1 simp set have have rw ring_nf rw ring


classical induction empty simp ext simp insert rcases simp simp show congr nth_rw rw left exact


by_cases rw have apply_fun dsimp rw revert nontriviality intro rw


refine rw rcases exact simp simp by_cases refine rw exact


calc split_ifs exact exact congr ext simp


MulChar.finite

have have let let have refine have refine simp exact


by_cases refine refine contrapose rw exact


classical have refine simp exact let let have use rw refine ext push_cast exact rw push_cast exact


rcases simp simp tsub_self, suffices apply intro calc p


have intro calc simp simp_rw let calc mk mk ring_nf simp_rw mk mk rw have intro rw exact rw mk mk simp rw rintro rw have rw exact rw ring1 have simp simp norm_cast simp norm_cast simp ring_nf rw refine refine simp


rw refine rw exact rw obtain rw refine rw exact


induction zero succ rw apply rw exact exact


rcases simp have simp rcases conv_lhs rw rw h.emultiplicity_eq_multiplicity] rw exact exact rw rintro refine rwa


obtain iterate rw rw rw push_cast exact simp


induction zero succ hd suffices rw rw ring


have have have refine rw exact rcases grind suffices rw decide intro rw


have have have rcases simp have simp rcases rw norm_cast rw exact simpa simpa norm_cast contrapose rw conv_rhs exact


have rw replace convert abel obtain subst simp have rw simp simp rw emultiplicity_mul suffices norm_cast rw rw decide rw apply simp


obtain iterate simp rw rw convert rw rfl simp top_add,


rcases contradiction rw iterate exact exact simp exact


niven

obtain obtain rw exact have rw rify constructor rw fin_cases


apply replace constructor generalize have simp_all grind


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


classical let let let rw rw simp] rw congr rw show simp


refine by_contra have let have simpa contrapose rw rw aesop have have obtain exact


let have rw exact have let have obtain dsimp rw exact have exact


let obtain exists_isConj_of_isRamified have intro obtain rw exact exact


IsCyclotomicExtension.Rat.isCMField

have obtain have obtain have have have exact have exact


obtain obtain refine exact exact lift simp_rw


obtain simp have rw convert ext rintro exact rintro exact


classical let let let suffices rw exact let rw rw convert rw exact


rw let suffices refine have apply rw rfl simp_rw


obtain by_cases have exact have pi_noAtoms exact


refine replace refine rintro exact ext1 rw by_cases apply rw exact rw have cases inl inr apply rwa


NumberField.mixedEmbedding.indexEquiv

refine cases inl inr rcases exact intro by_cases exact by_cases exact exact rw


suffices rw det_basisOfFractionalIdeal_eq_absNorm rw congr ext simp_rw exact


let refine rw refine suffices rw exact rw exact


intro refine obtain exact exact lt_irrefl


ext rw refine rintro simp_rw rwa exact obtain exact refine exact exact


ext obtain simpa congr_arg simpa congr_fun


classical let refine exact rw rw exact rw


simp_rw refine by_cases exact specialize rw rwa simpa exact by_cases simpa rw rw exact


have intro rw simp_rw rw ext simp_rw ofReal_mul show refine exact exact calc simp_rw rw congr refine rw simpa simp_rw convexBodyLT'Factor rw simp_rw ring simp_rw ofReal_coe_nnreal,


obtain suffices ext refine rw linarith suffices ext rw exact


let refine rw rw measure_fundamentalDomain rw ext1 rw


classical have rw simp_rw rw simp_rw exact obtain refine exact split_ifs


refine contrapose obtain refine rw exact


classical refine unfold refine measurable_pi_iff.mpr exact exact


classical let rsuffices exact obtain exact


classical refine rw let refine rw exact rw exact rw exact


refine rwa mixedEmbedding_preimageOfMemIntegerSet, exact


ext refine rintro refine rwa exact rwa rwa exact


induction mem obtain simp_rw zero add smul


classical have refine simp_rw convert simp have intro have rw exact rw exact


ext by_cases rw simp logMap_expMapBasis, pow_le_one_iff_of_nonneg refine split_ifs exact exact refine rintro exact rintro exact


classical obtain refine rw intro split_ifs refine simpa have contrapose rw rw congr split_ifs simpa rfl


classical simp obtain refine rw exact split_ifs rfl simpa


classical ext by_cases simpa refine simp exact


classical rw suffices obtain refine rw refine simpa refine exact


have intro rw exact ext refine rintro refine rw exact rwa intro simpa


have simp_rw rw simp_rw rw erw rw congr refine split_ifs exacts exact measurable_const.indicator


ext refine rintro refine rw exact intro refine rw rintro refine obtain simpa rw simpa


have rw simp_rw have refine rw exact have rw rw exact rw mul_assoc] refine rw refine rw exact


obtain obtain obtain have contrapose rw rw let refine suffices exact rw absNorm_apply, refine exact


refine rw refine by_cases simpa rw refine exact le_of_dvd absNorm_dvd_absNorm_of_le hI


refine obtain have nonZeroDivisors.coe_ne_zero eq_bot_of_comap_eq_bot have simp have rcases have have refine simpa have refine suffices exact have simp exact exact


refine swap rintro exact let have letI have obtain rw replace rw one_mul, cases haveI have rw exact obtain replace obtain rw exact have have have rw rw show rw exact refine adjoin_le simp exact


have refine obtain refine simp exact rintro exact


letI refine apply rw simpa rw convert apply rw simp exact


have refine apply rw simpa rw cases convert apply rw simp simpa hζ.norm_pow_sub_one_two convert apply rw exact


have have dsimp rw sub_one_norm_eq_eval_cyclotomic eval_one_cyclotomic_not_prime_pow


intro let have simp replace rw refine simp ne_of_gt by_cases simp exact exact one_lt_mul_of_lt_of_le rw replace have rw simp rw pB.basis.repr_self_apply] simp rw map_smul, pB.basis.coord_apply, simp exact


by_cases have simp have refine rwa replace ext exact rw exact suffices have have rw rw simp exact


have obtain refine coe_submonoidClass_iff.mp have rw show map_sub rw rsuffices obtain by_cases obtain have cases zero succ rw refine by_cases cases zero rw exact succ rw rwa rwa rw exact exact rw refine rwa have rw exact rw exact


have have let apply rw convert have rw exact rw congr ext simp_rw pB₁, convert simp_rw


IsCyclotomicExtension.Rat.discr

haveI rw congr induction zero prime_pow have rw cases zero succ simpa coprime have have let have have have have replace have have have replace have have have have rw exact exact have rw refine refine exact have have have rw hK₁, primeFactors_mul have p.totient_prime simp_rw rw


have rw refine refine exact have have apply exact replace replace replace replace rw refine rw exact simp exact


haveI induction zero prime_pow have rw coprime have have have have replace replace have have replace replace have have have rw exact exact exact


rw replace convert rw exact refine rw exact


have obtain rw exact rw replace hμ.map_of_injective have have have have rwa exact have obtain rw apply have rwa exact rw have rw exact rw exact


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


have have refine rw span_singleton_eq_span_singleton.mpr conv_lhs enter rw rw


have have have have have rwa inertiaDegIn_eq_inertiaDeg ramificationIdx_span_zeta_sub_one, exact


replace let have rw exact have have simp rw rw simpa refine rw simp


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


apply rw nrComplexPlaces_eq_totient_div_two simp one_mul, suffices gcongr exact


have apply rw nrComplexPlaces_eq_totient_div_two simp show suffices lt_trans gcongr exact


replace obtain exact have fin_cases left right all_goals exact apply obtain rw refine simp exact apply obtain refine have simp val_pow_eq_pow_val,


rcases contradiction left exact right exact


refine refine simp congr rw show show simp


classical have rw conj_basisMatrix, mul_eq_right₀, simp rw exact obtain rw grind rw rwa


let let let let suffices calc volume rw measure_fundamentalDomain rfl rw det_reindex_self] have rw nnnorm_pow, rw ext dsimp rw latticeBasis_apply, stdBasis_repr_eq_matrixToStdBasis_mul rfl


classical let have refine rw div_mul_cancel₀, inv_mul_cancel₀ exact exact convert rw div_mul_cancel₀ congr rw calc simp_rw volume_fundamentalDomain_latticeBasis, mixedEmbedding.finrank, rw simp_rw π⁻¹ simp_rw mul_neg_one, ring π⁻¹ congr rw ring rw zpow_natCast] ring


obtain have rw exact replace rwa mul_pow, exact


refine le_trans rw let suffices refine simp gcongr exact rw exact intro induction base succ h_m suffices convert_to simp_rw field_simp simp ring rw convert field refine exact


have refine rwa have rw linarith obtain apply rw have contrapose rw rw refine lt_of_le_of_lt rw inv_mul_cancel₀ refine rw exact exact


have simp_rw refine rw volume_fundamentalDomain_latticeBasis, show gcongr exact rwa exact exact


classical let let let refine finite_of_finite_generating_set simp_rw have haveI obtain suffices obtain have refine exact rw refine rw refine rw gcongr exact exact exact refine exact rw convert simp simp calc minkowskiBound


classical let let let refine finite_of_finite_generating_set simp_rw have haveI obtain suffices obtain have refine exact rw refine rw refine rw gcongr exact exact rw exact refine exact rw convert simp simp calc minkowskiBound


refine rintro have haveI obtain by_cases apply exact apply exact


let rw discr_eq_discr change rw congr ext simp rfl


replace intro convert simp classical rw congr have obtain have have obtain refine suffices rw exact rw rw rcases simp simp


refine rw refine have one_ne_zero have refine rw let let have ext let simpa qify refine rw exact apply rw apply rw simp simp rw congr ext simp


obtain refine apply rw exact apply rw exact rw


apply suffices contrapose have refine rwa exact exact


let have rwa h₁.finrank_left_eq_finrank ext exact


refine contrapose intro rw have by_contra exact use simp rw rw linarith


have ne_iff_lt_iff_le.mpr simp_rw have apply simp have refine simp


rcases simp_all obtain simp_rw apply intro simp contrapose simp


let calc rw exact gcongr exact gcongr exact simp


simp simp rw simp apply rw specialize let have ext specialize rw simp apply simp exact


funext have intro have rw rcases rw specialize simp rw exact have simp have conv rw rw conv rw rw ring rw rw rw rw


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


let intro have have calc simp_rw gcongr simp unfold gcongr simp gcongr exact simp rw gcongr exact exact rw


classical let have have have have have simp rw have have have exact use


rw refine ext simp_rw constructor rintro exact rintro exact


classical have toMixed have obtain have convert simp_rw mul_comm rw rw inv_pow, ring_nf rw rwa dsimp rw exact rw volume_frontier_normLeOne]


classical convert rw ring filter_upwards have simp_rw refine let simp_rw rw


intro rw obtain have refine exact hζ.prime_dvd_of_dvd_norm_sub_one


refine obtain suffices intro let have rw refine exact


have rw finrank_quotient_span_eq_natDegree] refine exact


constructor intro obtain let have change apply intro rw apply suffices rw rfl exact cases inl left conv_rhs exact inr right conv_rhs exact rintro exact rw exact


classical convert rw simp rw have rw simp_rw rw


suffices contrapose rw refine exact refine by_cases rwa exact rw exact


rw intro have have simp rw contrapose exact rw cases inl rw exact inr refine have rw have simp rw exact rwa exact


suffices rw simp_rw rintro convert rw refine exact rwa refine rwa simp_rw


refine rw let have have rw congr have rw have rwa cases inl inr replace simp lia


classical refine choose let have refine simp_rw refine by_cases rw have simpa simp have simpa simpa let exact


have rw refine classical rw obtain exact


classical let have refine have refine rw exact rw refine rw


rw cases inl obtain use rw inr h obtain use rw exact


refine rcases exact rw rw by_cases exact exact


refine by_contra rw rw letI letI have let have exact


classical rw by_cases obtain simp by_cases left right left trans congr simp simp


by_cases cases rw exact convert by_contra exact


rw refine obtain rw trans congr rw intro rw rwa simp


rw refine obtain rw trans congr rw and_iff_right_iff_imp] intro rw rwa simp


classical refine replace refine convert ext convert_to rw rw


simp refine norm_cast have rw let have let let have have refine simp intro simp classical refine congr have rw exact


rcases apply have rintro simp simp_rw finprod_div_distrib prod_eq_inv_abs_norm_int rw congr have refine norm_cast rw


rw refine refine exact have rw exact rw exact


by_cases rw linarith interval_cases linarith exact rw simp


rw refine by_cases suffices rw exact rw exact exact ext rw


have nth_rw refine all_goals by_cases have replace simp_rw refine rw exact refine rw refine simp have rw refine exact nth_rw exact


obtain convert rw exact suffices refine rintro refine exact rw exact refine refine rintro exact


have let suffices obtain obtain exists_ne_zero_mem_ringOfIntegers_lt refine rw calc simp_rw exact refine exact intro rw exact


induction zero exfalso exact succ cases inl rw exact inr refine exact


cases zero have contrapose simp simp succ rw exact


obtain conv exact rsuffices have refine calc rw inv_mul_cancel₀ rw exact refine rw exact


classical refine le_antisymm let let logEmbedding suffices rw rw refine rw refine simp_rw rw sum_erase_eq_sub refine rw exact rw refine rw refine rw exact


classical refine refine exact refine convert ext refine rintro exact


rw refine rw infer_instance rw have exact


let have rw simp_rw rw exact refine simp rintro simp nth_rewrite rw


classical have change rw have rw rw span_int_eq_addSubgroupClosure, rfl have rw refine rw rintro exact rw simp


let let rw abs_mul, simp_rw rw congr rw rfl simp_rw f.apply_symm_apply, intro rw


obtain contrapose refine rcases simp simp set have exact


rw constructor rw rintro simp rintro rw by_contra obtain refine rwa have have have have rw exact


obtain have have obtain simp_rw refine have rcases simp rcases simp padic_eq_padicNorm, rw simp field_simp by_contra apply rw rcases simpa


set set have lt_of_le_of_lt calc f simp refine dsimp replace push_cast rw refine simp exact


contrapose intro have set calc f simp refine simp exact mul_le_of_le_one_right rw simp exact natLog_le_logb rcases simp have have calc f rw gcongr exact gcongr exact rw rcases simp refine nth_rw have exact


have let calc f rw gcongr linarith simp gcongr exact rw exact apply le_of_pow_le_pow_left₀ nth_rewrite rw rpow_mul mul_comm calc


obtain have contrapose rcases rw set refine rcases obtain have simp exact linarith simp simp simp rw have rw have rw rwa


have have obtain have simpa have calc exact


have calc let let simp have have by_contra have have lt_irrefl rw exact exact


let let simp have have by_contra have have lt_irrefl exact


let change have have obtain obtain obtain simpa refine sub_add_cancel simp_rw smul_eq_mul, exact


have rw rw add_zero, have simpa simp sum_sub_distrib]


rw refine rw refine rw refine mul_le_mul_of_nonneg_right rw have rw exact refine calc rw exact apply simpa apply rw


suffices intro induction zero simpa succ rw refine rw refine rw exact_mod_cast exact div_le_div_of_nonneg_left


refine have tendsto_const_nhds.div_atTop obtain refine obtain rcases simp have obtain obtain exact filter_upwards simpa


have hasSum_mahlerSeries convert refine simpa


obtain use rw rw apply norm_cast apply convert exact exact


rw apply rw intro have congr rw_mod_cast rw have calc have simp exact apply rwa


rw constructor rintro suffices rw exact contrapose rw nth_rewrite simpa


wlog rw exact have calc padicNorm have apply intro rw exact have apply apply rwa


nth_rw simp constructor intro rw exact exact simp split_ifs rw intro exact have rw have intro rw


nth_rw rcases simp simp rcases simp rw exfalso rw rw exact simp


intro induction zero coe x induction ofAdd simp_rw rcases exact exact


constructor intro by_contra unfold split_ifs apply intro exists intro have simpa intro simp


classical exact have simp have simp unfold have simp rw apply


have obtain let have have rw have rw have apply apply apply exact


classical exact have simpa have change change have have have rw have change change have have have rw


classical exact have simp have simp let have apply apply exact have apply apply exact rw


classical have exact have have have have rw have have have have rw unfold split_ifs rw rw exact


padicNormE.defn

dsimp suffices by_contra obtain rcases have rw exact unfold apply cases inl inr have rw exact


refine have refine rw apply exact apply simpa


constructor intro contrapose apply rw calc rintro push_cast rw calc rw exact


Padic.instCompleteSpace

apply intro let refine rcases have simp exact


refine change rw rw apply contrapose apply simpa


rcases simp refine neg_injective rw exact


obtain simp have have have rwa zpow_right_inj₀


simp by_cases rw exact by_cases rw exact by_cases rw exact rw exact


ext by_cases rw exact rcases interval_cases simp dsimp rw simp


padicValRat.defn

have let rw simp rw rw simp_rw ring simpa simpa


padicValRat.mul

have have have have rw conv_rhs rw ring simp simp


induction zero succ rw by_cases rw exact refine refine exact


induction singleton rw exact cons rw exact padicValRat.lt_add_of_lt


by_cases rcases have calc rw calc rw lia


rcases simp intro simp obtain rw refine exact


apply rw padicValNat_eq_emultiplicity exact


induction zero succ rw hn padicValNat_eq_zero_of_mem_Ioo zero_add]


have simp rw padicValNat.mul simp rw tsub_tsub_assoc


refine obtain refine simp refine simpa exact


rw simp have simp add_zero] push_cast rw suffices rw simp apply apply rw apply rw exact


let rw suffices convert simp apply simp norm_cast simp exact


rw have simp specialize apply_fun simp simpa


simp obtain have rw calc obtain lift use constructor exact simp rw apply apply simpa


convert dsimp rcases change rw apply simpa


ext rw constructor intro simpa intro rw dsimp convert norm_cast apply


induction zero succ simp have split_ifs apply calc apply apply apply apply rw apply


obtain induction zero succ rw dsimp split_ifs exact rw apply apply apply


simp induction zero succ intro dsimp split_ifs rw apply push_cast rw obtain simp have rintro simp contradiction conv_rhs congr simp rw rw apply obtain simp rw suffices rw apply lift rw exact simp rw exact


ext rw constructor intro suffices convert simp dsimp rw apply intro rw dsimp rw apply


apply ext rw simp simp dsimp rw rw apply rw rcases use rw


intro rw intro obtain use rw apply rw apply


intro obtain use intro refine beta_reduce norm_cast rw exact


intro change use intro haveI suffices rw


intro obtain use intro dsimp apply rw dsimp simp rw simp


intro obtain use intro dsimp apply rw dsimp simp rw


intro obtain norm_cast obtain use intro apply change norm_cast exact


obtain limNthHom_spec have rw dsimp rw apply rw convert simp simp


constructor intro ext apply intro change rw rintro rfl


intro obtain simp refine obtain clear induction zero succ have simpa


set let have obtain rw obtain padicNormE.defn replace rw push_cast simp have by_contra have refine simpa rw exact rw refine clear induction zero succ rw exact


have have have have rw simp constructor intro use intro set set rw change rw rw simp split_ifs simp simp simpa zpow_right_mono₀ simp intro use intro set set rw change rw change simp split_ifs simp rw simp_all simp


simp refine rw ring_nf rcases positivity rw simp


let have refine rintro refine rw obtain have refine have have rw push_cast rw sq_sub_sq, refine rw rw refine rw exact obtain contrapose refine simp have rintro obtain rw obtain rw exact haveI let obtain hm.exists_ne_map_eq_of_mapsTo obtain have rw push_cast rw norm_cast rw have rw push_cast rw replace refine qify field_simp norm_cast grind qify refine exact


obtain have have lift norm_cast exact classical let obtain refine rw have have rw norm_cast refine rw exact


have intro rw rw refine add_pos_of_pos_of_nonneg rcases simp exact refine rcases exact let have rw exact


simp refine calc a₁.y rw suffices rw mul_pow, calc a.y


lift induction h rcases refine simp ext have rw refine have norm_num exact have have have have lift obtain exact


obtain obtain rcases exact exact exact rw rw exact


obtain refine obtain obtain obtain rcases rw zpow_add, rcases rcases rw rw exact rw exact rw have norm_num


have rw exact dvd_sub delta rw exact rw exact


rw have n.eq_zero_or_pos.resolve_right h cases


constructor rintro refine refine set have have have have set have have set set obtain have refine calc n lift have apply rw exact have zify lia have exact rintro exact exact have have rcases have apply rintro exact have have calc n have have have rw exact have apply rw exact have rw rwa


rcases rcases exact let have rcases have calc let haveI have have rw apply exact have refine exact have haveI have rw exact


induction h rcases rcases rcases decide calc rcases decide calc


rcases exfalso apply apply apply apply apply left exact right exact exfalso obtain obtain obtain rw exact apply rw rw ring] simp decide


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


PythagoreanTriple.normalize

by_cases have apply apply have apply apply have simp exact rcases obtain have norm_cast rwa rw rw rwa


suffices rintro norm_num rw have rw exact rcases apply apply


subst change rw rcases use rw decide use rw decide


by_contra obtain apply rw apply rw rw exact


by_contra obtain rw have convert ring have convert ring have have by_cases have simp decide have apply rwa rw exact apply rw exact


by_contra obtain rw have rw norm_cast exact rcases rw rcases have revert rw apply simp zero_sub] decide apply apply apply rw exact rw apply apply apply rw apply exact


obtain obtain rw subst subst have have have rw decide refine have rw by_contra obtain apply rw rw apply apply convert ring apply convert ring


have have apply rw norm_cast use apply right refine rw norm_cast


by_cases exact let let have simp simp norm_cast have have contrapose rw exact have intro apply exact have let have apply exact let let have unfold norm_cast apply have have have have calc w have calc v have have rw exact rcases exfalso have lia apply apply exact apply apply apply exact apply exfalso have coprime_sq_sub_sq_sum_of_odd_odd have apply change rw rw norm_cast lia norm_num


PythagoreanTriple.classified

by_cases have apply apply have apply apply use simp apply apply apply


constructor intro obtain use rcases refine have rw ring simpa refine have rw ring simpa delta rintro first constructor constructor


obtain rcases use rcases apply apply rcases apply exfalso revert rw exact exfalso rcases rw exact use rcases rw rw apply constructor rw ring rcases apply constructor delta rw exact rw apply lia exfalso revert rw exact exfalso rcases rw exact


PythagoreanTriple.classification

constructor intro obtain use rcases refine have rw ring simpa refine have rw ring simpa rintro


classical let have intro refine exact rw refine obtain exact


classical rcases simp rw have refine exact rw exact


dsimp congr ext simp rw e.toRingEquiv_toRingHom,


classical by_cases obtain simp rw constructor intro have have push_neg obtain exact intro have lia


rw intro replace rw pow_two] have rw exact exact


have refine rw normalizedFactors_irreducible exact


classical have rintro exact have rw obtain rwa


refine let rw intro obtain have rw convert on_goal rw simpa


have rw exact let obtain have calc p rw have intro obtain refine rw exact choose exists_sum let let have intros simp have intro calc simp mul_zero, simp rw rw have intro rw obtain rw rw obtain rw conv lhs intro exact refine top_le_iff.mp rw refine refine have calc refine rw simp refine rw intro rw exact


contrapose simp obtain use obtain choose letI let have exact have simp exact refine have rw refine intro rw simp


let let let have funext let have have let rw rw refine intro have b.mem_span rw b_eq_b', obtain suffices rw exact have convert rw exact exact


rintro have rw sup_eq_left.mpr suffices obtain obtain refine simp refine rw letI rw normalizedFactors_irreducible rw rwa intro rw have contradiction


let refine dsimp rw assumption dsimp rw exact


letI letI have by_cases have apply rw have simp


set set calc rw refine rw refine rwa exact


classical by_cases simp have rw refine exact


classical have have have letI rw rcases have have nth_rw normalizedFactors_mul by_contra simp exact exact add_eq_left.mpr hntq


have have have simp letI letI letI letI exact


obtain have rw ramificationIdxIn_eq_ramificationIdx exact


let let let rw rw apply intro rw obtain rw


trans rw simpa rw have have congr have rw convert rw refine intro ext rw convert simp


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


let have have have have rw have refine by_cases have subst exact rw rw intro have rw replace rw refine exact


rw intro rw rw div_lt_iff₀ have have simp_rw rw simp_rw exact


intro have have simp_rw rw simp_rw exact


cases exact refine rw constructor rwa exact


ext by_cases exact simp simp have have exact


apply rintro rw exact rw exact intro have intro refine rw exact_mod_cast have intro refine rw exact_mod_cast rw exact


rw intro norm_cast fin_cases simp simp ring_nf rw exact suffices convert rw ring apply exact exact


obtain exact simp zpow_natCast, neg_one_pow_eq_ite] grind


induction zero succ calc simp goldenRatio_sq] ring


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


rcases rw simp multiplicity_of_one_right refine rintro rw subst have rw exact


refine constructor rintro refine rw rintro exact


by_contra rcases clear have rcases obtain simp rw refine assumption_mod_cast assumption_mod_cast


have have calc s.nu apply intro simp apply intro apply simp


have calc siftedSum rw gcongr exact simp_rw congr congr rw ext rw simp_rw


rw have rw refine all_goals simp gcongr rw rcases rw exact rw simp exact rw gcongr apply rw exact


calc apply intro simp positivity apply intro positivity


by_contra apply ext simp rw specialize rw norm_cast exact


zify rw rify calc refine have rify linarith simp have simp ring simp_rw gcongr rw exact rw gcongr have exact congr rw div_mul_cancel₀] exact gcongr exact exact


classical rcases refine have rw intro simp rw refine norm_cast rw rw constructor simp apply norm_cast simp exact simp apply norm_cast simp exact


have refine obtain simpa mem_list_primes_of_dvd_prod


intro simp simp obtain have contrapose exact exact


rw suffices have have refine simp rwa rw simp


obtain have refine simp refine rw exact rw congr simp exact


intro obtain obtain simp refine have simp exact rw refine nth_rw gcongr exact


rcases use rcases rcases rw have refine rw positivity lift refine replace refine exact exact exact exact


have f set obtain this rw simp rfl set obtain simpa obtain refine rw mul_right_inj have simpa


classical have have a.natAbs rw have obtain refine simpa rcases rcases use exfalso have by_cases rcases rw have apply_fun push_cast obtain exact obtain refine exact obtain simp push_cast norm_cast simp rcases replace obtain simp have rw exact have rw apply rsuffices have refine conv_rhs simp rw exact hmin replace rw ac_rfl have simp refine simp suffices simpa norm_cast simp simp simp


induction zero one prime mul rcases rcases exact


set set let suffices convert rw ring suffices rwa cast_two, mul_le_mul_iff_right₀ calc exact_mod_cast exact_mod_cast


intro obtain specialize rw have convert simp refine convert obtain have refine exact


by_cases simp exact simp refine intro rw exact


refine induction zero one prime_mul have have by_contra exact have exact ih


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


induction zero one prime_mul have have obtain obtain exact


obtain have rw exact have linear_combination refine conv_rhs rw exact


constructor rintro by_cases exact have obtain exact rintro obtain exact


refine rw gcongr rw convert rw rw intro rw gcongr simp apply rw exact rw exact


obtain let let let use intro refine simp_rw have gcongr


have have refine fun_prop obtain simp_rw refine specialize grw simp_rw real_smul, refine rw split_ifs rw exact push_neg exact


simp_rw choose use intro obtain specialize use constructor rw contrapose exact obtain refine refine rw intro specialize rw rw exact rw have rw have rw aeval_sumIDeriv_eq_eval, refine have simpa have simpa


Liouville.irrational

rintro rw rcases have have have replace rw one_mul] exact replace rw exact lift have lift norm_cast exact


have lt_max_iff.mpr refine by_cases exact have refine exact refine gcongr exact refine gcongr apply


set obtain have obtain obtain refine exact one_le_pow₀ rw rw refine exact change rw rw refine one_le_pow_mul_abs_eval_div refine refine refine exact


Liouville.transcendental

rintro replace obtain exists_pos_real_of_irrational_root rcases obtain lx have zero_lt_one.trans refine lt_irrefl rw refine refine refine gcongr refine rw gcongr norm_cast lift specialize rwa exact


induction zero succ rcases use rw norm_cast rw simp all_goals


have have intro rcases refine push_cast rw rw have simpa


use refine have have rw exact refine rw gcongr calc


rcases refine refine rintro refine gcongr apply


LiouvilleWith.mono

rcases refine refine gcongr exact_mod_cast


rcases have simpa refine rintro replace refine rwa


rcases refine rintro have refine rw rw simp calc rw simp all_goals


rcases refine rintro have rw nth_rewrite push_cast rw refine refine have simp


LiouvilleWith.neg

rcases refine rintro refine convert rw congr


rintro rcases refine have rw gcongr norm_cast rw rw exact


by_contra simp rcases have intro replace have simp exact refine exact have rcases rcases lift rcases refine gcongr exact_mod_cast exact


rintro rcases rw suffices y simp have simp exact clear refine rintro rw refine replace have replace refine calc simpa rw sub_lt_iff_lt_add, rw push_cast refine simp rw exact


simp refine rw refine generalize replace clear refine simp set have rw have calc volume measure_biUnion_finset_le simp have rw simp refine refine


refine refine rw exact simp refine rw exact


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


apply rw constructor exact simp apply transitivity rw sum_divisorsAntidiagonal gcongr simpa rw simp gcongr simpa


suffices rwa simp refine simpa sum_divisorsAntidiagonal


have tsum_geometric_of_norm_lt_one simp have rw rw exact


have have have rw simp_rw rw tendsto_const_sub_iff] exact


rintro obtain replace apply convert simp


rintro obtain replace rw apply convert simp


simp_rw mem_setOf_eq] refine simp refine rw exact


simp_rw mem_setOf_eq] replace intro rw rw rwa dvd_trans let have rintro refine rw apply simpa simp simpa


pieces that invariant letI set set have exact have rw have refine obtain exact set set set set set have have have refine exact have intro simp congr ext tauto have rintro rw exact have rintro let suffices apply apply exact blimsup_thickening_mul_ae_eq refine replace exact have rintro let let suffices apply apply exact blimsup_thickening_mul_ae_eq refine rintro have obtain rw exact replace have simp_rw rw have specialize simp refine convert rw change rw have intro let change rw exact by_cases replace intro replace have refine rw exact right obtain rw cases rcases simp rcases simp


let have suffices obtain refine simpa rw exact by_contra apply have rw refine simp_rw exact replace by_contra refine suffices rw simp have simpa


refine calc rw simp_rw have symm refine intro rw constructor apply intro exact intro intro rw refine intro simpa simp rintro


rcases norm_num replace by_contra obtain have refine rw


have let suffices rw exact induction zero intro simp sub_eq_zero] rw succ h have simp div_mul_cancel₀ apply rw exact refine simp apply rw exact simp have is_const_of_deriv_eq_zero generalize have simp rw integral_bernoulliFun_eq_zero eq_comm right rw simp rw simp intros intros exact exact simp m0, simpa


rcases rw refine rw simp rw rw zero_sub, ring


have rw simp_rw refine have ext1 simp simp_rw rwa


convert ext1 rw conv_rhs congr rw congr rw apply rw


have convert rw rw conv_rhs rw congr congr skip rw ring have convert convert rw rw rw ofReal_mul, congr ring ring convert rw ofReal_two, rw ring


have convert ext1 rw sub_eq_add_neg] congr rw conv_rhs rw congr congr skip rw ring have convert convert rw rw rw ofReal_mul, neg_div, congr ring ring convert rw ofReal_two, have rw rw ring


convert ext1 rw have rw conv_lhs congr skip rw rw lia rw ring


apply ext1 ring_nf have rw simp rw linarith linarith


constructor rintro simp rintro use rw exact


apply rintro obtain rw simp rintro apply obtain rw apply rw exact exact


apply intro refine simp have simp grw gcongr


refine intro have refine convert simp ring


constructor intro rw have have obtain ext exact rw exact rintro exact


Zsqrtd.Nonneg.add

rcases trivial refine dsimp exact apply refine dsimp exact apply refine dsimp exact apply have rw rwa exact refine dsimp exact apply dsimp rw exact have rw rwa


obtain refine change rcases simp trivial have simpa rw exact


refine dsimp rw by_cases obtain haveI exact suffices rw simpa false_or, apply rw exact


rw exact le_mul_of_one_le_right rw exact


refine change refine push_neg have disjoint_iSup_iff.2 le_bot_iff.2 of_not_not have hx obtain exact


refine have of_not_not have have have have ha.1 exact


ext refine obtain obtain simpa assumption


constructor exact exact eq_bot_or_eq_top


refine rintro exact rw rintro exact eq_singleton_iff_unique_mem.2


have simp split_ifs try rfl contradiction) have contradiction grind


refine by_cases exact exact rintro exact exact


refine have rw exact this.imp le_antisymm


rw apply calc x rw inf_sdiff_sup_right, calc x


obtain have intro obtain obtain refine refine simpa choose use constructor apply rintro apply apply apply intro rw apply apply use simp rintro apply rw exact


obtain obtain simp exact suffices have rwa exact


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


obtain revert classical refine simp exact


contrapose intro induction ind by_cases exact intro obtain exact


refine suffices exact suffices exact exact exact


classical refine suffices exact exact exact


rw apply apply constructor constructor exact exact exact rintro rcases left right right intro refine by_cases left rcases have right apply


apply constructor refine intro exfalso exact exact rintro refine intro have rw rcases rcases exact exact exfalso exact intro refine intro obtain by_contra apply apply intro exact have rw exact obtain exact have rw apply intro exact


refine intro let let let change have ext exact rw rw


constructor intro dsimp by_contra let let ofHom simp split_ifs any_goals exfalso exact rfl⟩ let ofHom simp split_ifs any_goals exfalso exact rfl⟩ have congr rw ext simp change split_ifs any_goals exfalso exact exfalso exact simp intro exact


constructor intro exact intro rw rw exact


classical rw constructor intro let have rintro use constructor use constructor simp simp simp have apply intro use simpa have suffices use simp obtain obtain use exact intro obtain have obtain exact


classical rw constructor intro obtain have choose refine rw intro rw exact intro obtain delta rwa refine rw exact


classical rw let have rintro exact iSup_le_iSup_of_subset have h.trans le_sSup_of_le obtain exact


rw by_contra have replace obtain obtain exact


classical simp_rw intro rw rw apply rintro obtain specialize specialize simpa


simp_rw refine obtain use rwa obtain have suffices simp intro exact exact


classical by_contra obtain replace have obtain exact obtain replace have simpa apply rw exact


by_contra let let have sup_le_iff.mpr have exact exact


refine simp_rw intro classical rw set replace have ext simp refine obtain exact rw specialize rw exact


by_cases rw intro obtain obtain exact rintro exfalso exact


constructor rintro obtain left right have refine cases exact intro by_cases refine intro exact simp not_false_iff]⟩


iSupIndep.iInf

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


have zorn_subset swap rw rintro exact rw exact simp_rw obtain refine simp_all rw intro rw refine rw refine rw have rw exact rw exact rw obtain simp exact have simp rw rw exact rw apply rw rw obtain exact exact


Set.Iic.instIsCompactlyGenerated

refine obtain rw let refine rintro exact rw change congr ext simpa


apply have replace obtain refine replace simp_rw rintro exact choose let have rintro exact have rw exact


refine rcases have rwa have rwa have rwa


let refine calc iSup_le refine refine rw


let refine rw refine have by_contra choose have contradiction refine refine obtain exact


rw refine le_antisymm by_cases exact simp


simp but begin apply simp, begin ematch, trace_state, end end


by_cases simp refine by_cases rw obtain exact exact


induction obtain exact exact union refine exact


induction succ refine obtain exact exact union apply apply simp intro obtain exact obtain exact exact


rw refine rw intro obtain cases contradiction assumption


classical obtain change split_ifs rcases cases exact rw exact


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


classical constructor change split_ifs intro exact rintro contradiction apply exact intro exact change split_ifs rintro exact exact rintro exact refine rcases exact exact intro exact rintro exact exfalso apply use intro exact


classical constructor change simp split_ifs intro exact rintro exact refine rcases exfalso apply intro rw exact use intro exact change simp split_ifs intro exact rintro exfalso apply intro exact refine classical contrapose rintro exact exact intro rw exact


by_cases exact exfalso apply use intro exact


obtain obtain rfl refine refine simp intro obtain exact


constructor intro refine classical refine intro simp grind simp refine simp have grind


constructor intro refine classical refine intro simp grind simp refine simp intro have simp obtain rw exact


simp simp congr apply rintro simp rintro simp


classical refine intro have rw refine simp_rw refine intro simp intro split_ifs exact simp_all refine simp_rw split_ifs exact exact


have have refine have refine intro obtain have exact rw refine simpa rw


classical rcases have simp by_cases have rcases refine rintro by_cases simp simp apply apply by_cases simp left exact simp apply rcases rw convert simp apply rintro convert simp convert simp have simp apply contrapose apply rintro convert simp


cases simp by_cases exact have simpa simp


let let obtain simp obtain obtain exact refine rintro obtain simp exact obtain simp exact ext simp


by_cases obtain exact have intro rw rcases rcases rw rw exact obtain use rintro have rcases have rw exact have rw exact


cases rcases obtain haveI let let refine rcases rcases rcases exact


cases cases let let let let exact rcases rcases rcases exact


refine obtain exact exact rintro exact exact


classical simp obtain refine let have have exact


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


constructor intro obtain have obtain obtain exact rintro have refine exact


rw constructor rintro exact rintro exact


intro rcases use simp rcases use simp rcases use simp


DirectedOn.insert

rintro exact obtain exact obtain exact obtain exact


obtain obtain ext1 refine ext obtain exact have rw nat₂ ext have have rw ih


constructor intro refine all_goals rintro exact


disjointedRec

classical intro rw suffices intro induction empty insert rw exact


classical suffices intro induction zero simp simp succ rcases exact simp have simpa rw simp simp simp refine ih rw apply simpa refine simp exact


classical have simpa rw rw partialSups_disjointed]


classical ext have rw simp rw simp simp congr simpa


let induction rfl succ by_cases simpa rw simp exact


rcases exact let let have refine intro simpa simpa exact


let have rintro haveI refine refine trans antisymm simp_rw intro exact rintro haveI haveI rcases exact exact rintro haveI haveI rcases exact apply obtain haveI refine intro by_contra let rw apply refine trans antisymm rintro exact exact exact exact rintro exact exact exact exact


refine obtain rw filter_upwards calc b rw exact


refine obtain have filter_upwards calc b rw exact


simp choose use constructor apply intro apply intro cases


have choose refine rcases exact have rw intro filter_upwards exact


haveI apply refine refine rw refine simp refine rintro exact refine simp exact


obtain choose set have refine refine rw apply refine rw apply


refine contrapose have rcases rw refine rcases exact


contrapose obtain obtain refine rcases exact


rw apply rw rintro exact rw rintro rcases have have exact


rcases by_cases refine exact refine exact


intro obtain exists_max_image have obtain rcases push_neg exact use rintro have rcases exact exact calc u


simp choose refine rw have refine rw exact


rw refine intro obtain obtain simp refine convert_to rw congr lia congr lia refine rw apply exact exact exact


rcases exact by_cases refine obtain exact obtain simp


filter_upwards calc a rw gcongr try first positivity apply simp_rw


refine le_antisymm rintro refine rw exact


cases subsingleton cases subsingleton simpa


classical apply intro simpa intro use exact


have rintro rcases use simp exact ext simp


refine rw refine rintro rcases exact rintro exact


simp refine rintro rcases exact rintro exact


Filter.HasBasis.iInf

refine rcases exact rintro refine cases exact


have let have have use intro have rw exact have let univ_sets sets_of_superset inter_sets exact have let univ_sets sets_of_superset inter_sets have exact


Filter.skolem

classical refine refine filter_upwards exact


Filter.ofCardinalUnion

refine rw apply intro rw rcases apply rw rw exact


refine choose replace replace refine rw apply


constructor induction refine simpa univ superset choose refine apply apply rcases have exact


constructor exact intro induction basic univ superset sInter


refine refine rintro classical rw refine by_cases simpa simp filter_upwards simp


by_cases rcases have simp obtain refine exact obtain exact


constructor induction univ superset choose refine apply intro exact rcases refine intro exact


constructor exact rcases use rintro exact rintro exact hS


rcases refine exact intro simp refine cases inl inr exact inter_mem


use exact apply rw refine exact refine rfl


obtain rcases rw exact have let have antitone_nat_of_succ_le have rintro exacts refine have convert exact le_antisymm


Filter.iInf.isCountablyGenerated

choose rw refine refine rintro lift exact


simp constructor rintro exact rintro exact


simp constructor rintro exact rintro refine obtain exact exact


by_cases simp refine rw simp refine simpa


obtain simp by_cases simp have refine rw simp refine simpa


by_cases exact by_cases have simp simp have rw refine rw simp have eq_top_iff.mpr have simp


constructor induction univ superset rcases exact inter rcases exact rcases exact


constructor rw rintro rcases rw set have rintro have rw apply exact refine rwa rintro exact


classical simp refine rintro refine dsimp split_ifs exacts exact simp true_and]


constructor simp rintro choose refine simp gcongr exact rintro rw refine simp


classical simp refine rcases refine refine rintro simp rintro exact


refine obtain mem_prod_self_iff.1 refine rcases rw exact rw exact


rintro rw obtain have have eq_empty_of_subset_empty exact


obtain rcases exact refine specialize exact


obtain obtain refine filter_upwards have obtain exact exact


rcases rcases use intro apply rw refine simp


refine simp contrapose choose refine exact


refine have intro refine inhabit exact rw exact simp exact


constructor induction nil simp traverse_nil] cons intro rcases rcases rcases exact rintro exact


ext suffices simp constructor intro simpa intro exact


refine rw apply exact refine rintro exact


refine rcases rcases refine rw exact rcases refine rw exact


refine rcases refine rw exact rcases refine rw exact


constructor simp rintro choose exact rintro exact


classical rcases refine have choose have simpa


constructor simp contrapose rintro have choose exact simp rintro filter_upwards


refine obtain have rw obtain refine rwa rwa rintro rw


constructor rintro obtain refine rw exact rintro exact


rw congr ext constructor rintro simp rintro use simpa


Filter.Tendsto.if

simp intro filter_upwards rw split_ifs exacts


constructor intro have simp intro refine exact


intro obtain wlog obtain exact rfl replace rw exact


rcases dsimp induction refine have specialize simp rwa rwa


constructor rintro exacts revert rintro exacts


induction induction refine rintro exacts


induction induction refine induction rw dsimp rintro exact exact rw exact rw exact


refine and_congr_right classical obtain exact obtain exact cases


by_cases exact obtain contrapose refine exact_mod_cast obtain exact


refine contrapose obtain refine rw exact


refine rw disjoint_compl_compl_left_iff, exact


refine rw codisjoint_hnot_hnot_left_iff, exact


rw exact sup_le_sup proof logic intuitionistic.


simp refine try refine rw exact refine rw exact


constructor intro refine obtain exact intro refine obtain exact


constructor exact intro have intro induction zero succ intro calc f^ calc f^


apply intro push_neg apply intro obtain obtain exact obtain exact obtain cases


constructor intro obtain refine rwa rintro exact


Interval.completeLattice

classical exact sSup obtain lift exact le_sSup split_ifs exact cases exact apply constructor apply exact exact sSup_le split_ifs exact obtain lift exact iSup₂_le sInf iSup₂_le sInf_le split_ifs lift ne_of_mem_of_not_mem h.1 let exact exact le_sInf intro cases bot coe split_ifs exact le_iInf₂ rw rcases exact exfalso apply intro have repeat rw exact


classical change split_ifs ext simp simp_rw rcases refine exact refine rintro rw exact


intro induction subst obtain refine exact


have card_lt_card by_cases exact obtain have calc have have exact termination_by


refine rw suffices rintro rw obtain have replace rwa refine constructor simp intro have obtain simp refine simp rw simp rw simp


wlog convert by_cases simp have have simp grind


wlog convert by_cases simp by_cases simp simp exact have by_cases simp convert simp rw intervalGapsWithin_snd_of_lt have set have hF contrapose simp use have have simp


intro rw wlog exact rw suffices have have simp grw rw exact


induction zero simp rintro simp rwa succ ih rw rintro have simp rcases rfl rw refine simpa rw suffices refine simpa refine


obtain rw ext simp constructor rintro exact intro have obtain refine rw refine simpa refine rw rw refine lia lia rw


rw convert ext simp constructor lia rintro exact


apply intro rcases exact exact rintro rcases specialize all_goals


classical by_cases refine rwa insert_eq_of_mem refine rw exact rwa refine rw exact rwa refine rw apply_rules


refine have simp obtain obtain obtain obtain exact


ext constructor rintro apply refine ext simp


orderIsoIooNegOneOne

refine refine have calc x refine intro simp rintro simp hy.trans_lt refine have simp


revert refine rintro by_cases rw exact obtain specialize nth_grw refine exact exact


let refine rintro exact rintro exact rintro refine apply exact


constructor rw ordConnectedComponent_ordConnectedProj, exact simp


rw rintro rcases clear rcases clear rw wlog exact obtain obtain have rw calc clear rcases exact rcases exact have lift suffices hsub rintro rw have have exact


simp_rw refine suffices intro suffices exact by_contra obtain have obtain have have have have exact


ext rw refine rintro simpa simpa ext obtain exact simpa


obtain intro rcases exact exact rw exact


constructor rintro exacts contrapose rw rintro exact exact


simp_rw rintro first assumption exact exact


rintro rw obtain have simp or_false] refine simpa refine simpa


classical induction empty insert simp rw exact


classical apply clear rintro by_cases exact rw obtain exact obtain obtain exact


refine obtain exact obtain have rw exact


refine simpa by_cases simp_all have rw intro obtain simp_rw exact


refine induction isMin succ intro obtain exact exact isSuccLimit intro have exact


Order.IsNormal.ext

constructor simp_all rintro ext induction isMin succ isSuccLimit apply convert aesop


refine obtain rw obtain exact rw apply rw simpa


induction zero succ ihn suffices cases zero succ refine


simp constructor rintro have simp intro exact


have have subsingleton_of_length_eq_zero s₂.last_mem, ext simp


induction zero exact succ have by_cases use simp have isMaximal_of_eq_inf have rcases have isMaximal_of_eq_inf use refine have s.Equivalent conv_lhs exact refine this.trans


set let le_refl le_trans le_antisymm rintro obtain rw have simp or_iff_not_imp_left] rintro refine have exact congr_arg rintro refine rintro replace obtain rw have simp_rw rintro have exact obtain obtain refine simp exact have refine simp exact obtain have refine convert


apply intro wlog simp_all let rw apply simp


by_cases let p.eraseLast.snoc apply apply convert simp congr suffices simp p'] convert norm_cast lia refine simp simp_all


cases top have rw gcongr simp coe apply rw gcongr simp


have cases top clear rw contrapose use rintro simp by_contra apply coe rw rw obtain simp use constructor simp simp


apply apply intro cases zero succ apply apply rw apply apply rw apply apply


wlog simp_all simp trans rw simp congr exact simpa


wlog simp_all simp cases simp simp rw simp congr rename_i cases


by_cases cases zero succ suffices simp obtain use simpa


rw refine obtain refine rintro let have exact


simp_rw contrapose constructor rintro iterate exact rintro exact


refine cases simp cases rw cases infer_instance


cases simp cases rw constructor exact exact simpa


apply apply intro suffices apply rw apply apply


apply rw apply wlog simp_all rw apply intro have have cases top coe cases top coe obtain obtain apply


rw apply apply let simp exact apply have rw refine exact


obtain apply intro use simp intro by_cases subst exact suffices apply lia


apply apply intro wlog simp_all let toFun apply apply exact step have simp congr lia suffices apply rw apply intro let apply


apply apply intro let toFun apply apply exact rw simp step have suffices rw simpa apply apply intro let apply


generalize cases top coe induction h refine let suffices obtain have have rw add_comm refine gcongr rwa refine let let le_antisymm have simp have lia


intro exact closed_interval suffices rw simpa exact simpa


apply rw refine rcases filter_upwards exact refine rintro exact


rw simp_rw conv_rhs simp refine simp exact


classical rcases let have have apply apply by_cases have conv_lhs apply simp simp apply exact have intro apply change by_cases simpa simp have rcases exact rcases exact exact simp_rw


StrictMono.ite'

intro by_cases have simpa by_cases simpa simpa


inhabit rcases rcases refine rintro exact change rw exact exact


obtain contrapose let m exact replace replace exact


induction zero succ by_cases exact obtain replace use specialize


classical of rcases have let have intro simp have rw refine by_cases simp rcases exact exact rw gcongr


classical letI refine obtain obtain exact obtain rintro exact


StrictMonoOn.union

have intro cases assumption rcases exact exact have intro rcases exact exact intro rcases have rcases exact exact have have exact


constructor trans exact assumption exact


rw simp constructor apply exact rw apply


simp constructor split_ifs swap rintro intro have simp subst exact intro have rw have rw simp


apply simp constructor intro apply rintro simp rcases replace simp replace replace apply simp exact intro simp rcases apply apply apply


constructor apply apply trans apply apply apply apply apply


rw apply apply intro simp have rw apply apply rintro apply change apply have rw apply


apply intro induction zero succ h_ind have rw exact


classical let by_cases refine have rw exact rw obtain by_cases refine exact have intro have simp obtain refine convert lia let exact


obtain refine obtain induction zero succ apply exact exact


refine obtain exact rw refine obtain exact


choose have classical let refine have change rw exact have by_contra exact exact


suffices simp ext simp constructor exact exact


simp apply exact sup'_le le_ciSup_of_le exact


let let simp_rw simp_rw let apply simp exact replace replace let use intro simp_rw by_cases


obtain obtain let have have rcases calc rw exact let have refine simp_rw haveI change simp apply_fun exact use intro simp_rw


by_contra refine rw rintro obtain refine rintro simp exact


rw constructor rintro exact rintro exact


constructor intro have refine rintro obtain exact


suffices refine rw rw simp_rw rintro refine simp


refine rintro dsimp obtain by_contra rw exact rwa


induction singleton obtain by_cases refine simp exact exact


Order.Ideal.IsMaximal.isPrime

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


set have refine have intro use refine simp let refine obtain obtain set use have clear refine have isProper_of_notMem rw intro contrapose intro let let have have have have have have have intro apply simp exact have intro apply simp exact let let let let let have have calc c₁ have contrapose rw use exact


classical constructor intro exact intro apply


intro induction h induction h induction on_goal all_goals rename_i cases inl inr


rw revert apply cases exact rw rw exact rw rw exact exact


RelHomClass.acc

generalize intro induction intro subst exact


intro rcases have rw exfalso exact exact have rw exfalso exact


constructor exact intro induction intro refine obtain exact


RelEmbedding.ofMonotone

haveI refine refine exact exact refine subst exact exact


refine length_ne_zero_of_nontrivial⟩ nth_rw convert ext simpa


simp constructor rintro exact intro rcases exact exact


RelSeries.inductionOn

let induction zero convert ext exact simp succ have nth_rw convert exact exact


RelSeries.inductionOn'

let induction zero convert ext exact simp succ have have convert exact exact


rw push_neg constructor intro induction zero succ obtain obtain exact intro obtain exact


obtain induction zero succ obtain obtain let have refine refine on_goal all_goals rw obtain cases refine convert convert simp all_goals


wlog obtain exact funext wlog obtain exact funext obtain refine rw rw


have have simp simp induction base succ specialize have norm_cast


refine apply simp exact apply apply apply simp intro exact trans rw apply rw apply


rw refine exact apply exact apply apply apply apply


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


ScottContinuous.prod

refine have simp_rw exact have simp_rw exact


Succ.rec

obtain induction zero succ simp_rw exact


obtain obtain clear wlog rw apply exact left obtain rw apply


rintro have obtain suffices obtain exact have apply exact rintro exact


obtain obtain by_cases exact have revert refine simp intro rw simp_rw replace intro refine rintro exact by_cases exact exact


rintro obtain clear induction zero succ rw have by_cases rw exact exact


rintro obtain obtain simp apply induction zero succ rw have by_cases rw exact exact


refine contrapose exact ext suffices exact


induction zero succ rw have rcases simpa rw have rw exact refine have exact rw simp rw exact


rcases rw refine simp intro rw by_cases rw rw


refine obtain obtain contradiction exact


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


rcases have rw lia rw refine norm_cast exact


let have by_cases nth_rw rw exact suffices exact


rcases simp have refine have exact let have by_cases nth_rw rw rw exact suffices exact


rcases rw exact exact exact rw refine exact


by_cases rw by_cases rw rcases let have have rw nth_rw rw rfl by_contra obtain rw rw exact refine have rw exact rwa exact exact exact let have have rw nth_rw rw rfl by_contra obtain rw rw exact refine refine exact have rw exact rwa


revert intro exact intro have rcases rwa exact


unfold generalize cases have rw apply simp simp simp rw apply


cases simp simp apply by_contra have exact


Set.Finite.supClosure

lift classical refine rintro simp mem_filter] exact


simp constructor exact rintro simpa rintro simpa exact rintro exact rintro exact


Finset.SupIndep.biUnion

classical intro obtain let let apply calc a.sup symm apply exact rw exact


classical refine let let suffices apply suffices grind


classical refine suffices grind suffices grind


constructor intro exact rintro convert simp convert simp


refine simp intro cases inl inr convert have rw simp


iSupIndep.injOn

rintro by_contra apply suffices replace rwa replace exact


constructor exact rintro obtain refine rw refine rw


classical rw refine rw congr refine congr simp


intro induction isMin obtain obtain rfl succ obtain refine dsimp rw apply rfl isSuccLimit obtain dsimp rw exact rfl


have by_cases subst rw exact obtain grind by_contra suffices have simp exact refine rw exact


IsUpperSet.total

by_contra simp_rw obtain obtain exact exact


refine by_contra obtain refine by_contra exact


intro ext apply intro obtain obtain rw cases rw obtain have rw rw cases


have refine rw intro by_cases rw rcases exact rcases exact


let refine rintro refine rintro exact exact


simp constructor rintro have refine simpa rintro refine simpa


refine rw intro by_contra refine obtain refine rw exact exact refine rw exact rintro obtain exact exact


Set.PartiallyWellOrderedOn.pi

haveI haveI trans suffices rw intro simp simpa refine intro exists simp intro obtain obtain refine exact


rw rintro refine exact range_subset_iff.2


contrapose rw obtain rw obtain use exact


rintro let refine exact exact have obtain induction zero succ ih rw rfl refine dsimp rw exact refine rw


rcases exact inhabit rw rintro have obtain have hf2 swap simp rw exact rw push_neg obtain hf split_ifs exacts by_cases apply rwa obtain rw split_ifs apply exact rw apply rw exact


rw intro rw obtain hα have by_cases obtain use constructor by_contra simp_all exact have intro exact obtain simp_rw apply intro rw simpa use suffices refine exact exact


Set.PartiallyWellOrderedOn.fiberProdLex

let have ext simp rw apply rintro simp have simp_all


refine obtain exact dsimp convert exacts


refine obtain exact dsimp convert exact exact dsimp grind


obtain refine obtain exacts obtain cases


WellQuasiOrdered.pi

haveI haveI trans suffices rw intro simpa refine intro exists simp intro obtain obtain refine exact


refine obtain exfalso apply exact contrapose refine rintro obtain exact contradiction exact refine obtain rfl cases


constructor intro obtain induction bot coe simpa


constructor intro obtain induction top coe simpa


have rcases exact rcases exact rcases exact


have obtain exact rintro refine rintro obtain exact rcases exact exact


refine have obtain refine exact rcases exact


have rw atTop suffices atTop} have ae_all_iff.2 filter_upwards refine simp_rw have rw exact rw refine refine rw exact rintro refine rw specialize refine rw rfl rwa simp exact


obtain simp by_cases simp simp integrable_const_iff_isFiniteMeasure


calc have have rw exact have filter_upwards condExp_mul_of_stronglyMeasurable_right condExp_ofNat simp simp


constructor simp rcases simp rcases simp simp


ext change rw inter_right_comm, all_goals first exact exact exact exact exact exact


refine simp_rw intro rw refine rw gcongr rw fun_prop


rcases simp obtain rw let invFun left_inv right_inv rw rfl


refine rw simp refine rw congr rw have fun_prop


refine exact contrapose have filter_upwards


split_ifs simp rw exact pos rw simp rw rw integral_eq_lintegral_of_nonneg_ae have rw rw rw rw norm_num simp exact have exact simp exact refine rw exact refine rw exact


calc μ rw rw rw swap refine change exact change exact congr simp have simp rw nth_rw rw congr rw rw refine simp intro suffices calc suffices calc calc b have linarith


let have replace have have have rw simp simp refine congr rw norm_cast exact


refine rw refine simp finiteness refine refine rw rwa


unfold gcongr refine rw exact simp exact simp finiteness finiteness finiteness


by_cases simp mul_nonneg_iff_of_pos_right, refine rw refine refine rw rw exact simp finiteness calc logRatio gcongr exact exact unfold field


let let let have change c have calc refine gcongr exact simpa simp rw simp field_simp congr simp by_cases simp refine rw refine rw rw change rw filter_upwards refine rw exact measurableSet_le have have have ext simp not_le, simp_rw rcases exact exact rw have refine gcongr exact lintegral_iUnion_le refine rw gcongr exact rw gcongr refine gcongr simp field_simp exact gcongr simp gcongr refine all_goals exact simp finiteness simp exact finiteness finiteness


have by_contra have ext simp exact simp simp cases inl ha simp refine rw gcongr simp exact inr refine conv_rhs gcongr exact


let replace have have have refine rw rwa have refine simp refine refine refine refine change simp and_self, rw exact


by_cases obtain exact obtain by_contra push_neg suffices have have by_contra refine exact rcases calc μ exact have ext simp exact rw simp intro simp exact hx.trans have rwa refine rw exact refine refine integrable_of_le_of_le exact filter_upwards simp gcongr


by_cases exact let have have have calc simp obtain refine rwa simp simp


calc charFunDual rw simp congr rw simp exact


ProbabilityTheory.instIsGaussianMapHAdd

refine rw have rw variance_add_const simp rw congr simp ring


refine rw congr let let rw congr simp_rw rw norm_cast field_simp rw norm_cast


refine isGaussian_of_map_eq_gaussianReal apply ext simp_rw norm_cast congrm rw ring exact


have simp_rw choose have rw field_simp ring have rw change simp_rw fun_prop have have rw simp simp ofReal_im, div_left_inj', constructor rw simp rw apply intro simp


let f.bilinearComp have simp have have refine ext simp


refine ext simp_rw rw congr norm_cast have ext simp rw simp have ext simp rw simp rw simp rw covariance_smul_right, have grind all_goals


rw simp calc congr rw simp rw simp rw simp


have rw replace simp filter_upwards rw convert simp left simp_rw obtain let have suffices refine integrable_of_le_of_le exact exact intro rw gcongr have calc simp_rw gcongr exact calc


suffices rw simpa lift convert simp obtain have refine integrable_of_le_of_le filter_upwards simp positivity have rw exact exact


simp_rw have classical let rw intro have simp_rw sum_mul, congr simp_rw rw rw simp congr rw covariance_self


have have rw let let refine exact rw simp_rw rw simp refine rw simpa simpa


have rw intro have simp rw add_mul, rfl exact exact exact exact


have have have rw let let refine exact hXY.map_equiv rw simp_rw rw simp refine rw simp exact simp exact


have rw intro apply simp rw sub_add_sub_comm, hY.charFunDual_map_eq] congr any_goals exact rw exact exact exact rw exact


classical let map_add map_smul cont exact


rw by_cases simp let have suffices rw refine simp ext simp neg_mul, hv, rw left field exact


rw have have rw simp rw simp simp_rw rw simp positivity


by_cases simp exact let have change ext rw simp rw simp


by_cases simp exact by_cases simp rw simp convert simp let have suffices exact change ext rw swap simp rw simp simp congr suffices rw rwa


by_cases simp calc simp_rw unfold push_cast simp_rw congr congr ring cexp congr simp ofReal_ofNat, rw push_cast ring_nf rw congr have simp ring


rw simp calc rw simp have ext rw simp deriv_id'', ring rw simp


have ext have conv_lhs rw congr simp positivity


unfold split_ifs cases inl rw positivity inr positivity


have have setLIntegral_congr_fun rw rw simp linarith rw filter_upwards apply refine simp_rw


ProbabilityTheory.poissonPMFRealSum

let unfold apply simp have ext rw rw exact


classical simp rintro by_cases simp calc setBer infinitePi


classical lift calc setBer simp simp rw simp


by_cases simp by_cases filter_upwards hx simp have have apply rw exact


by_cases have apply filter_upwards simp simp have constructor exact refine set have simp rw exact


PMF.uniformOfFinset

classical refine simp have simpa exact exact


refine rcases refine apply filter_upwards


by_cases have rw rcases refine rw filter_upwards exact change rw rw rw rw rw rw


by_cases simp by_cases simp apply exact simp congr apply exact


refine by_cases swap obtain refine have ext simp_rw exact rw simp_rw let have have intro ext simp rw eLpNorm_map_measure


rw have μ constructor refine rw intro rw


classical rw have μ constructor congr rw rw congr simp constructor refine rw simpa intro specialize h₀ simp rw


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


refine exact rw congr ext rw rw exact exact


have classical cases let calc exact congr calc simp rw exact rw intro by_cases obtain exact exact rw exact refine by_cases simp simp


rw refine rw convert any_goals all_goals


refine have f classical rw split_ifs have classical rw split_ifs have refine exact rw gcongr exact simp_rw rw integral_const_mul, integral_const, simp ring exact exact exact exact exact exact


simp have have intro simp_rw rw exact have refine exact refine have filter_upwards rw exact refine exact refine exact filter_upwards have have rw congr exact


simp have condExpKernel_ae_eq_condExp have condExpKernel_ae_eq_condExp have refine have filter_upwards rw refine filter_upwards have rw exact


rw simp_all constructor intros simp grind simpa


rw swap exact refine refine exact classical let specialize simp exact have intro rw simp convert


rw rintro rw calc μ refine condExp_stronglyMeasurable_mul_of_bound rw split_ifs nth_rw exact exact


have have have isProbabilityMeasure_map have rw congrm rw


refine iIndepFun_uncurry exact rw change rw infinitePi_map_pi congrm change rw infinitePi_map_pi any_goals exact exact any_goals exact


obtain contrapose have obtain exists_seq_strictAnti_tendsto filter_upwards simpa have have hindep.measure_inter_preimage_eq_mul simp exact


revert have h_mg.mul apply intro simp_rw rw lintegral_indicator simp rw rw intro have simp_rw rw h_ind_g] intro have simp_rw rw simp_rw exact exact


revert have apply intro apply apply rwa intro have simp_rw rw intro have simp_rw rw simp_rw exact exact


have induction empty cons simp apply exact exact exact


refine have have apply filter_upwards simpa refine have have simp rw simp


have have have by_cases have filter_upwards simp simp by_cases have filter_upwards simp simp by_cases have change rw any_goals rw exact rw obtain not_and_or.1 all_goals


refine hfg.integral_comp_mul_comp rw rintro specialize h rwa measureReal_def, integral_indicator_one exact


have change rw integral_fintype_prod_eq_prod] congr rw fun_prop rw exact


intro let have classical have simp_rw exact filter_upwards simpa


intro rw rcases simp refine rcases rw rw


classical intro have intro rcases simp simp have filter_upwards grind


rcases simp induction empty basic compl filter_upwards rw measure_diff measure_compl exact iUnion rw filter_upwards rw simp exact exact


rcases simp intro induction empty basic refine rw exact compl filter_upwards have rw measure_diff iUnion rw filter_upwards rw rw rw congr rw intro rw exact exact


rintro classical let have have intro rw rcases have simp_rw exact have simp_rw exact have ext1 simp exact filter_upwards rw filter_upwards ha2 have intro dsimp split_ifs exact all_goals simp_rw


classical rcases simp obtain exists_ae_eq_isMarkovKernel apply rw refine exact exact exact exact exact


classical rcases simp obtain exists_ae_eq_isMarkovKernel apply refine exact exact exact


let have have have let have have have refine conv intro rw exact refine exact