rintro rw classical let have intro dsimp rcases simp grind have have suffices intro have simp_rw have filter_upwards rw have have have rw filter_upwards rw have filter_upwards rw


classical rcases simp obtain exists_ae_eq_isMarkovKernel apply intro refine simp intro have let set have have have have exact have filter_upwards rwa have intro rw exact have exact


refine induction hC empty compl iUnion induction hC empty compl iUnion


refine intro classical let have intro simp_rw exact have intro simp_rw exact simp_all


rw intro have filter_upwards have apply filter_upwards change simp have apply filter_upwards change simp convert exact


ProbabilityTheory.Kernel.iIndepFun.comp

rw refine have filter_upwards simp_rw exact


classical rw refine rw intro rw refine have simp_rw filter_upwards by_cases swap simp rw map_apply exacts intro rw refine exact exact intro specialize rw convert rw rw


rcases simp obtain exists_ae_eq_isMarkovKernel apply let let have have rw congr let let have have rw congr refine rintro simp rw classical let have have simp_rw let have simp_rw have have have ext1 simp_rw grind have ext1 simp constructor intro rintro replace rw have ext1 simp_rw constructor grind exact have intro rw rcases rw exact rw exact filter_upwards h_indepST rw congr refine rw refine rw


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


classical have f f rfl have measurable_pi_apply let have ext1 simp constructor have rw refine rw simp exact


have refine exact refine filter_upwards hi filter_upwards rw exact


have refine exact refine filter_upwards hi filter_upwards rw filter_upwards hk filter_upwards rw


classical have f f rfl have measurable_pi_apply have ext1 simp have rw have rw exact h_meas_right


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


classical rw rintro simp_rw apply have refine exact exact


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


let have have rw rfl refine rintro simp have ext have filter_upwards rw


obtain simp obtain exists_ae_eq_isMarkovKernel apply let have have rw rfl refine simp choose simp_rw have have filter_upwards rw congrm ext


rcases simp obtain exists_ae_eq_isMarkovKernel replace apply apply exact exact exact intro obtain refine exact exact


suffices rw exact rw refine have haveI rw


let have refine simp rintro obtain refine suffices exact exact exact


refine ext1 rw simp_rw have ext1 rw congr rw rw


classical obtain refine simpa intro contrapose exact obtain refine filter_upwards simp refine by_cases simpa simpa


have have filter_upwards suffices filter_upwards refine refine simp calc rw fun_prop


by_cases swap by_cases swap let have symm refine rw have have have filter_upwards rwa simp


suffices filter_upwards rwa rw have refine exact


rw lintegral_dirac'] swap suffices p exact congr rw comp_apply] simp rw lintegral_prod classical have rw simp simpa simp_rw rw exact


by_cases swap ext rw refine filter_upwards


refine simp_rw refine exact rw simp rw exact


classical simp let have rw convert suffices rw intro simp simp suffices rw intro simp simp


let have measure_mono have have have rw exact filter_upwards exact


ext rw simp have η classical rw split_ifs simp simp simp_rw rw


let have simp simp_rw have rw have intro rw exact exact simp_rw have intro have rfl rw fun_prop rw rotate_left exact exact congr ext1 refine intro simp rw swap exact congr ext1 rw intro simp_rw change rw swap exact congr rw exact


by_cases swap by_cases swap by_cases swap have refine have ξ rw infer_instance simp ext rw lintegral_compProd] swap congr rw congr exact


by_cases swap ext simp_rw rw congr rw exact exact


ext rw refine rw congr grind exact exact


let simp_rw calc refine filter_upwards rw exact


simp rw have simp_rw enorm_eq_ofReal have rw rw intro filter_upwards rw intro


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


by_cases simp apply intro simp_rw integral_indicator measureReal_def] congr rw rotate_left exact exact rw intro simp_rw exact intro convert exact apply filter_upwards


simp_rw simp_rw enorm_eq_ofReal have rw rw intro rw filter_upwards rw finiteness exact


by_cases simp apply intro simp_rw congr rw exact exact rintro simp_rw exact rintro convert exact apply filter_upwards


ext rw swap simp id_apply] congr rw exact


by_cases swap ext rw rw congr rw congr rw


ext rw lintegral_prod_deterministic] congr rw exact exact exact


ext rw lintegral_deterministic_prod] congr rw exact exact exact


ext rw simp_rw rw swap congr congr rw exact


by_cases simp ext rw swap congr rw rfl exact


by_cases swap by_cases swap by_cases swap ext rw swap congr rw congr exact


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


by_cases swap by_cases swap by_cases swap by_cases swap refine rw simp rw simp


have have have rw filter_upwards exact exact exact exact exact


refine rw have rotate_left exact exact simp_rw exact


conv_lhs rw simp rw refine exact refine infer_instance exact exact


have ext rw exacts rw symm refine convert exact


by_cases swap have condDistrib_map inferInstance) rw simp exact


have refine exact rintro change simp rw swap rw exact rw setIntegral_map preimage_univ, exact


refine suffices refine rw by_cases rw rw exact exact exact rw simp contrapose


by_cases have refine rw exact rw simp contrapose


rcases simp rw have have rw congr ext simp congr


nontriviality rw convert hf_int.comp_snd_map_prod_id


rcases have simpa have simp simp_rw exact


rcases have simpa have simp_rw have simpa


classical induction empty insert rw haveI have exact


let refine have ext rw simp_rw change rw


have nth_rewrite rw classical have obtain simp congr simp simp have simp simp_rw rw simp rw


have by_cases swap suffices convert exact suffices filter_upwards have conv_rhs rw have constructor rw intro let have have intro by_cases simpa simp have rw contrapose conv_lhs gcongr finiteness rw intro let have have intro by_cases simpa simp have rw contrapose conv_rhs gcongr finiteness


by_cases rw have suffices symm refine simp exact suffices rw simpa rw simp have congr simp_rw rw congr simp refine exact refine exact exact exact obtain exact have obtain exact rw rotate_left intro rw exact refine simp_rw refine exact refine exact simp_rw rw rw congr simp exact exact exact exact


have ext rw exact rw refine refine exact rw exact


rw rotate_left exact exact rw exact exact


refine exact rw exact filter_upwards filter_upwards


suffices filter_upwards have rw convert simp suffices filter_upwards have exact exact


rw refine refine refine filter_upwards rw refine exact exact exact exact


rw rw congr simp refine refine exact exact exact exact exact


refine have intro rw refine exact exact filter_upwards calc rw exact rw refine exact exact filter_upwards


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


induction empty basic obtain exact compl calc rw exact rw exact exact rw rw simp rw exact iUnion simp_rw rw simp_rw exact exact exact


induction empty basic rcases simp rw have refine rw have suffices rw simp intro rw simp rw exact compl calc congr exact have rw exact refine rw exact iUnion hf_eq have simp_rw have intro have rw ext1 simp intro suffices rwa calc congr rw


simp_rw have rw suffices have ext1 push refine rw exact rw have rw exact refine refine simp refine exact


refine exact simp_rw rw refine filter_upwards


change have refine refine exact refine rintro exact refine change exact


have have simp_rw rw rotate_left refine change exact refine by_cases suffices have rw refine simp exact finiteness congr have refine rw rw simp by_cases simp have rw refine intro simp exact rw exact


have obtain simp_rw have intro simp refine rwa rw congr rw rfl intro simp exact exact exact exact exact


unfold by_cases rw simp have meas_countablePartitionSet_le_of_fst_le gcongr simp exact apply


unfold have meas_countablePartitionSet_le_of_fst_le by_cases simp gcongr simp exact apply


simp_rw by_cases simp_rw simp refine rw push_neg simp refine have apply measurability exact exact simpa


refine exact refine exact refine suffices ext simp refine rw exact simp


refine tendsto_setIntegral_of_L1 densityProcess refine refine exact


suffices exact suffices rw simp refine rw have rw


have have rw have rw exact isPiSystem_iUnion_of_monotone induction empty basic rcases exact compl have rw have rw simp rw rw exact gcongr iUnion h_eq rw simp_rw rw congr rw exact exact


have simp_rw have swap rw refine simpa simp exact refine convert rw


have simp_rw rw have refine have apply measurability exact exact simpa


rw split_ifs simp by_cases simp simp rw have ext simp rw simp rwa exact


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


simp_rw refine rw push_neg simp_rw constructor refine simp exact refine simp exact by_cases rw suffices simp suffices convert ext simp refine simp exact refine convert rw exact


refine exact rw convert simp rw simp exact exact


have change simp_rw refine refine refine exact have have have rw refine exact suffices rw exact ext simp refine exact exact


simp have refine obtain dsimp split_ifs exacts split_ifs refine obtain refine rw rwa split_ifs exacts refine refine split_ifs exacts refine rw rw exact


rw refine exact invFun left_inv right_inv intro simp


intro have obtain exact simp_rw refine refine exact rfl


rw convert rw have refine refine rintro exact have congr exact rw congr rw


refine classical rw split_ifs rwa rw simp


let let let have have change rw have ext unfold rw congr rw ext simp_rw refine have rw have unfold rw swap suffices ext simp rw swap simp exact filter_upwards rw rotate_left exact exact classical rw exact


let let let have have have ext unfold rw conv_rhs exact


have eq_condKernel_of_measure_eq_compProd suffices filter_upwards ext apply simp simp exact filter_upwards rw refine rw exact


let have set have ext rw exacts have rw refine ext conv_lhs rw congr rw exacts suffices filter_upwards rw ext rw h suffices rw have rw filter_upwards rw ext conv_lhs rw congr rw exacts exact


have ext conv_lhs rw rfl have rw filter_upwards rw


ext simp refine convert rw convert rw split_ifs exact exact


obtain induction base succ rw have exact rw


have ext simp rw map_comp_right symm_comp_self,


unfold let let change refine simp intro by_cases


ext obtain rw rw rw simp_rw updateFinset_updateFinset_of_subset rw fun_prop


intro obtain rw exact rw congrm exact refine rwa


have induction hz hi hm have exact nonempty_of_isProbabilityMeasure have choose let have simp_rw exact have simp_rw exact dependsOn_cylinder_indicator_const have lmarginalPartialTraj lmarginalPartialTraj refine rw simp have apply simp have have intro simp rw exact lmarginalPartialTraj_mono have obtain rw exact exact choose have have simp_rw exact obtain have hε have apply simp choose le_lmarginalPartialTraj_succ let have induction base succ intro convert ext simp split_ifs any_goals cases rw have simp_rw nth_rw exact simp_rw convert rw by_contra have have rw simpa exact exact


refine ext rw projectiveFamilyContent_congr exact exact


apply refine measurableCylinders obtain simpa simp_rw projectiveFamilyContent_congr refine exact have simpa simpa


have rw rw exact refine ae_eq_condExp_of_forall_setIntegral_eq rw rintro simp_rw rw all_goals exact


have have filter_upwards rw congr apply simp exact any_goals exact


classical by_cases simp borelize have let let refine refine simp_rw refine refine exact rw by_cases simp apply exact simp


induction empty basic simp obtain classical simp_rw have ext1 split_ifs exacts rw exact compl iht have intro ext1 simp simp_rw have ext1 rw exact exact rw exact iUnion hf have rw exact exact simpa


let have simp simp_rw have intro rw exact exact simp_rw refine refine intro simp exact intro simp have ext1 rw rw exact


suffices rw simpa suffices rw exact rw refine simpa


rw refine simp_rw calc rw rw simp_rw conv_rhs rw


have rw refine filter_upwards change rw have rw refine filter_upwards change rw refine refine calc intro rw


filter_upwards ext rw refine filter_upwards rw


refine rintro simp_rw rw measurability rintro simp rw rintro simp_rw rw simp_rw exact


refine rintro simp_rw rw measurability rintro simp rw exact rintro simp_rw rw simp_rw


simp_rw split_ifs refine measurable_from_prod_countable_right have ext exact rw have exact


have simp_rw split_ifs have rw refine filter_upwards rw have rw map_apply congr simp


have suffices withDensity withDensity κ ext have withDensity a κ rw simp simp rwa simp_rw rw rw exact fun_prop intro filter_upwards simp exact


rw all_goals rotate_left exact exact exact refine simp simp_rw rw tsub_self, simp simp simp


have rw swap calc refine have filter_upwards have simp suffices exact


have withDensity withDensity rw congr exact rw rotate_left fun_prop fun_prop exact simp_rw have simp_rw exact calc refine rw mul_inv_cancel₀, rw exact simp simp


have simp_rw specialize simp zero_add] rw exact


have simp_rw specialize simp add_zero] rw exact


have have ext rw swap have ext1 simp rw exact rw fun_prop have congr rw rw congr rw


by_cases exact rw calc rw infer_instance


by_cases swap let have intro have rw refine rw norm_cast exact have intro suffices exact have have refine suffices intro rw exact ext rw have induction zero succ rw simp simp_rw refine refine rw exact rw swap refine suffices refine isFiniteKernel_withDensity_of_bounded beta_reduce norm_cast calc fs


ext rw swap change rw rw exact fun_prop fun_prop


MeasureTheory.Supermartingale.add

refine refine filter_upwards intros refine


refine induction base refine rw succ hk filter_upwards hω2 grw


induction zero succ exact ih.trans congr_arg


induction zero succ exact congr_arg condExp_of_stronglyMeasurable ih


refine induction base refine rw succ hk filter_upwards rw


induction zero succ exact condExp_of_stronglyMeasurable ih


filter_upwards rw by_cases simp positivity obtain rw have simp exact suffices have lift simp lia


have rw exact filter_upwards rw obtain have intro exact have intro rw simp congr simp simp


set have have ext simp have filter_upwards convert refine obtain simp_rw exact exact refine exact refine have simpa


have filter_upwards simp grind have have filter_upwards have constructor exact refine convert simp rw constructor rw refine simpa rw simp_rw refine simpa


have have have refine filter_upwards filter_upwards constructor refine intro simp exact rintro rw simp exact refine rintro exact


have tendsto_sum_indicator_atTop_iff swap rw exact simp_rw simpa


refine have μ f rw refine refine refine rw exact exact refine have intro have condExp_condExp_of_le filter_upwards rw have k μ refine rw exact exact rw exact exact rw refine rw add_zero refine refine simp rfl


set have rw have rw exact have hf.sub refine filter_upwards unfold rw rw simp


filter_upwards simp have f f ring_nf rw exact


rw replace obtain exact rintro rw refine push_neg intro induction zero succ obtain obtain obtain exact


by_cases rw refine rintro exact obtain exact


refine have rw refine have simp_rw intro refine intro simp_rw exact simp_rw exact refine ne_of_lt le_trans refine rw by_cases rw rw exact finiteness simp left left


letI rw exact exact measurableSet_exists_tendsto


classical suffices rw exact set have have filter_upwards simp_rw exact have hg').aestronglyMeasurable obtain have filter_upwards exact exact


have ext1 simp exists_apply_eq_apply'] nth_rw rw intro have simp obtain specialize simp lift exact


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


refine refine exact suffices μ μ rw rw swap filter_upwards simp exact apply exact rw have apply exact exact rw exact


rw simp have intro refine convert ext simp rw refine rw exact exact exact intro exact exact exact


refine classical specialize hf intro simp split_ifs exact norm_cast rwa integral_piecewise integral_add_compl


rw intro simp_rw obtain have have simp exact h.expected_stoppedValue_mono exact exact


have have intro simp_rw refine simp exact let have setIntegral_ge_of_const_le_real rw exact exact exact


suffices ε have rw rw convert ext change simp rw rintro change change exact exact measurableSet_lt measurable_const exacts integral_nonneg rwa calc ε stoppedValue stoppedValue gcongr exact exact refine refine exact exact nullMeasurableSet_lt aemeasurable_const rw have classical intro exact simp refine congr rw rw convert ext change simp rw rintro change change exact exact measurableSet_lt measurable_const exact exact exacts refine rw refine hsub.expected_stoppedValue_mono simp


refine lt_of_le_of_ne not_le.2 simp rw exact


by_cases refine have refine rw convert convert rw exact


induction zero refine simp exact succ ih have intro simp_rw refine simp refine refine simp


rw exact intro simp obtain rw upperCrossingTime max_eq_right refine rw upperCrossingTime max_eq_left refine


intro change refine have have simp simp_rw exact


have have rw refine simp have μ μ μ simp refine integral_sub convert ext rw refine simp_rw


by_cases subst rw refine by_contra exact


have induction zero simp refine rw obtain exact exact succ ih specialize ih have rw simp obtain rw exact exact refine simp refine rw obtain exact


have refine rw refine rw obtain exact exact


refine rw refine rw refine by_cases have rw exact rw rw


have rw rw exact simp lowerCrossingTime_stabilize


classical by_cases simp simp_rw rw have stoppedValue stoppedValue intro rw rfl ext simp exact simp_rw have stoppedValue calc stoppedValue gcongr refine rwa stoppedValue refine by_cases subst simp rw by_cases rw rw exact rw rw exact refine rw


have have intro refine rwa rw rwa have induction zero refine simp simp_all succ ih have ext simp split_ifs simp_rw refine simp_all refine simp_all rfl refine ext simp split_ifs simp_rw refine simp_all refine simp_all rfl


by_cases simp rw have rintro rw rw rfl exact have rintro rw rw simp exact rw smul_eq_mul,


have upcrossingsBefore ext exact rw refine simpa


have constructor intro lift exact rintro exact simp_rw constructor obtain refine rwa refine simp


by_cases simp_rw have intro rw exact exact rw simp_rw intro rw lintegral_coe_eq_integral, simp_rw exact simp exact measurable_from_top.comp_aemeasurable filter_upwards rw exact rw rw exact


rcases simp by_cases rw simp simp have refine have rw fun_prop rw


simp_rw have rw have ext1 simp exact rw refine simp filter_upwards rw exact rwa


classical induction empty simp exact insert h_rec have h_int specialize rw apply


classical induction empty simp exact insert h_rec have specialize rw refine exact


have classical induction empty insert h_rec have rw h_rec,


rcases rw simp gcongr exacts calc μ.real congr simp exact have mul_meas_ge_le_integral_of_nonneg rwa


apply exact filter_upwards simp by_cases exact exact


have have rw obtain let have have refine exact exact fun_prop refine simp rw simp gcongr have rw gcongr refine rw gcongr refine simp exact refine exact exact positivity exact refine simp simp_rw refine simp_rw convert rw


induction zero succ rw have have refine exact filter_upwards rw exact


refine simp suffices intro simp rw exact


by_cases simp rw obtain have have rw refine have refine rw rw obtain refine rw constructor rw exact simpa simp


have apply rw specialize simp_rw simp ofReal_mul] rwa


simp_rw repeat simp_rw simp exact exact exact exact exact exact


classical induction empty insert h_ind rw exact exact exact exact


by_cases refine filter_upwards simp have rw


by_cases ext have rw congr rw simp rw simp exact ext rw rw contrapose convert ext


by_cases swap refine simp_rw simp positivity


by_cases swap simp positivity by_cases simp simp by_cases simp simp suffices rwa gcongr rw exact exact have suffices refine simp rw mul_inv_cancel₀ rw simp rw simp refine suffices rw gcongr rwa refine have rw simpa calc refine rw swap gcongr exact


by_cases swap calc refine simp_rw exact simp_rw refine simp_rw refine exact simp rw gcongr exact exact rw congr ring


have rw apply set by_cases simp rcases simp rcases exact apply have apply contrapose exact have apply filter_upwards lift simp rw rcases have calc rw ring gcongr positivity calc


refine by_cases have rw exact refine refine by_cases refine rw exact exact simp conv_rhs rcases calc exp calc exp


refine rcases rwa simpa rcases rwa rwa rw exact exact


rintro wlog rw exact refine simp calc t₁ simp calc a


have ht_int_pos.add refine by_cases simp exact have fun_prop rw simp simp conv_rhs rw rcases rw positivity rw le_add_iff_nonneg_left] positivity


by_cases simp exact have have have refine rw refine gcongr exact refine gcongr exact calc x| refine convert rw rw congr simp rw ring_nf congr


refine simp congr rcases rw simp positivity rw simp exact


have suffices exact have swap rw swap simp have simp_rw gcongr have nth_rw rw gcongr convert nth_rw simp nth_rw simp rw exact refine refine simp_rw exact fun_prop simp simp_rw refine congr symm simp exact


have swap rw simp_rw have refine fun_prop refine simp gcongr exact fun_prop


rw obtain let have have by_cases have rw refine simpa exact exact


rw obtain have refine positivity exact exact


have rw swap simp refine fun_prop refine simp gcongr exact


have rw norm_cast refine simpa have filter_upwards rw exact


induction zero succ rw have have filter_upwards rw exact


rw by_cases simp have have filter_upwards have filter_upwards rw calc deriv mgf rw rw exact exact exact mgf rw congr rw exact rw ring congr convert simp


by_cases simp rw calc deriv mgf rw congr rw ring exact congr simp_rw have simp_rw refine simp_rw refine convert simp rw rotate_left exact exact rw congr rw congr ring rw congr ring


have rw nth_rw convert have convert simpa exact simp


filter_upwards constructor exact by_cases simp rw have convert rw mul_assoc] positivity


by_cases simpa constructor exact rw simp have rw convert rw positivity


filter_upwards calc cgf by_cases simpa gcongr exact exact


refine change exact rw integrable_map_measure exact simpa


have ext simp constructor intro obtain exact intro exact have filter_upwards simp suffices have apply exact apply exact exact filter_upwards simp exact


by_cases swap by_cases swap constructor simpa have rw exact


by_cases swap rcases simp simp_rw refine have simp have rwa have rwa memLp_map_measure_iff


have classical induction empty insert h simp_rw have refine exact convert rw


calc μ.real congr grind refine rw refine exact grind congr grind


have have obtain rw gcongr calc convert exact exact


suffices have rw refine exact rw have simpa convert ext rw


induction zero succ induction zero succ specialize simp_rw refine refine refine simp lia


have by_cases simpa refine rw rotate_left simp simp simp_rw refine simp_rw exact


by_contra rw have refine rw simp exact refine convert ext rw


by_cases have rw variance_eq_integral simp rw refine have rw exact


rw covariance_add_right ring exact exact exact


by_cases rw simp rw by_cases simp exact rw exact intro have have apply convert simp exact exact


by_cases rw congr simp_rw rw simp simpa symm rw refine rw specialize simp not_and_or, exact


have have convert norm_cast rw simp rw congr simp_rw evariance]


by_cases rw symm refine simp have filter_upwards simp exact obtain obtain simp obtain have rw refine rw refine exact


have have have have have calc apply filter_upwards exact simp calc rw linarith


refine exact rw measurePreserving_snd.variance_fun_comp


refine ha'.symm suffices classical have rw exact calc congr exact


refine refine have have exact classical suffices p.tsum_coe exact


intro ext rw q.toMeasure_apply_singleton


refine induction simp_rw constructor intro simp exact intro simp simp


refine split_ifs refine exact refine exact


refine dsimp simp classical simp refine split_ifs any_goals absurd simpa simp


intro apply rw intro specialize rw exact


letI apply intro by_cases have apply have rw exact obtain have have by_cases simpa simpa exact simpa rw


simp ext1 refine rintro refine rw refine ext simp rintro suffices refine rintro obtain on_goal all_goals exacts


refine have rw have rw rw have simp_rw exact


simp split_ifs obtain change exact exact


classical intro have refine simp_rw exact


obtain classical rw conv intro rw exact exact


simp split_ifs refine obtain exact rw exact exact


constructor exact have obtain obtain refine exact obtain refine exact


constructor have have refine lift norm_cast obtain refine exact


constructor have by_contra simp_rw exact exact obtain refine exact


simp obtain rw refine refine by_cases exact change exact exact


intro simp split_ifs gcongr exacts obtain exact obtain exact simp


intro simp split_ifs norm_cast gcongr exacts simp obtain exact simp


intro simp split_ifs gcongr exacts obtain exact have exact simp


intro simp split_ifs norm_cast gcongr exacts simp have exact simp


intro have ext simp exists_prop] specialize have lift simp have ext simp iff_false, refine specialize have lift rw exact simp refine simpa


refine rcases suffices convert ext simp simp_rw exact


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


rw refine measurableSet_preimage measurableSet_preimage rw refine rintro rw simp ext simp iff_false, exact rw obtain rw simp ext simp rw grind rw exact ext simp intro rw exact


refine intro rw refine obtain exact rw exact


by_cases suffices ext1 simp rw cases top coe have ext push cases top coe simp rw rw exact


have ext1 simp exists_prop, constructor simp exact rw refine refine classical rw split_ifs lift exact exact


by_cases suffices ext1 simp cases top coe obtain h_lub.exists_seq_monotone_tendsto have ext1 push refine rw cases top coe norm_cast have obtain exact obtain exact have rw simp exact


obtain rcases rw exact have have rw rw exact


intro have ext simp cases top coe rw refine exact


intro simp have ext simp cases top coe rw exact


refine by_cases simp have ext simp cases top coe simp norm_cast simp_rw rw exact convert ext simp cases top coe lia


MeasureTheory.IsStoppingTime.add

intro simp have ext simp cases top coe cases top coe simp norm_cast lia rw exact


ext1 change rw constructor have simpa refine by_cases norm_cast simp exact norm_cast simp


have intro ext1 simp intro rw constructor simpa refine rw by_cases norm_cast simp exact simp


have ext1 simp cases top coe norm_cast rw rw exact


refine exact le_inf intro change simp_rw have simp_rw exact


simp_rw have s s ext by_cases simp_rw refine refine apply exact exact


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


refine let let let have have refine refine refine cases top coe j have ext1 simp iff_and_self] exact rw suffices h_meas exact letI suffices simp exact ext1 rw have by_cases simp lift norm_cast refine convert simp norm_cast


have refine cases top coe rcases simp simpa


have stronglyMeasurable_stoppedValue_of_le suffices ext1 simp intro rw


have stronglyMeasurable_stoppedValue_of_le intro refine obtain have stoppedValue ext1 simp rw intro by_cases exact lift simp rw exact rw refine exact have ext simp intro simp rw refine exact


ext classical rw suffices ext1 simp constructor simp simp specialize have lift simpa


ext rw rcases rw intro refine rw simp refine exact exact rw have specialize lift rw simp rw exact rw exact rw simp exact intro rw rw exact


have intro simp have lift exact rw congr simp


rw refine refine have rintro exact exact


rw refine exact suffices ext1 refine exact


have have rw swap ext simp refine ext simp specialize lift lift simp simp grind


refine specialize have lift simp simp grind


have ext rw simp_rw have ext simp cases top coe simp norm_cast rw rintro rw rw norm_cast grind rw


intro have ext1 simp by_cases rw by_cases have exact have have simp


have haveI rw exact sigmaFiniteTrim_mono refine rw


refine classical simp_rw prod_eq_prod_extend] refine rw rw


obtain refine simp_rw nth_rw congr rw rw rw exact all_goals


refine have rw congr simp mem_singleton] exact


obtain refine rw all_goals have rfl rw map_comp_right, any_goals all_goals have ext by_cases rw exact rw simp


obtain rw pi_map_piCongrLeft simp any_goals exact


have have choose let let classical let let invFun left_inv right_inv let have ext simp rw let f let have have have have have have simp_rw conv enter rw change rw obtain let simp_rw convert rw infer_instance have obtain conv convert rw infer_instance


intro ext rw piContent_cylinder exact exact


refine refine classical rw congr rw any_goals rintro split_ifs exact exact exact


wlog simp apply classical conv rw map_apply simp have rw grind rw apply refine exact intro simpa exact rw exact


apply intro classical rw coe_piCurry_symm, apply simp intro rw simp simp exact


ext rcases simp by_cases have simp simp simp


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


let haveI have calc apply rw intro exact simp_rw refine gcongr simp refine apply simp simp gcongr have simp simp_rw apply exact exact exact intro simp simp rw norm_cast exact rw exact exact rw gcongr rw simp rw exact have intro rw rfl calc congr refine rw


suffices intro have refine have apply intro obtain exact simp rw apply intro exact apply filter_upwards exact


set let have intro change rw calc simp_rw congr congr rw norm_cast intro exact simp_rw refine gcongr refine simp apply gcongr have rw refine apply apply calc have gcongr exact rw swap rw norm_cast mul_le_mul_of_nonneg_left rw exact zero_le_two


it this and the parts have have have stronglyMeasurable_id.indicator set set let have have intro calc gcongr rw exact let have intro calc congr congr rw intro exact intro exact simp_rw refine simp exact all_goals gcongr rcases simp simp apply convert simp simp simp_rw apply apply exact have intro calc gcongr apply exact apply refine apply rw apply rw exact apply simp_rw gcongr simpa have filter_upwards simp_rw convert


obtain exists_seq_strictAnti_tendsto have filter_upwards apply obtain filter_upwards simp exact


have convert ext exact convert ext1 simp rw exact


have convert ext1 exact have filter_upwards apply filter_upwards simp split_ifs exact have apply simpa simp exact filter_upwards convert ext rw


have intro refine simp filter_upwards h'ω rw have have tendsto_nat_floor_atTop.comp convert ext1 simp convert


obtain exists_seq_strictAnti_tendsto have strong_law_aux6 filter_upwards apply intro exact exact


let by_cases have rw intro exact filter_upwards simpa have hint.isProbabilityMeasure_of_indepFun let let have have have strong_law_aux7 have strong_law_aux7 filter_upwards convert simp simp


classical refine intro simp piecewise_eq_indicator, let have let have simp apply exact exact exact filter_upwards have ext rw congr ext simp simp convert simp rintro filter_upwards convert simp congr rw rfl exact exact


possible error to is let have have have let let have ae_all_iff.2 have apply let have have apply exact unfold simp_rw intro exact intro simp_rw apply filter_upwards rw refine intro obtain obtain simp_rw exact have rw exact exact have have specialize rw exact filter_upwards calc congr simp abel norm_add₃_le gcongr simp gcongr exact gcongr exact


by_cases have rw intro exact filter_upwards simpa have hint.isProbabilityMeasure_of_indepFun have let have have have apply strong_law_ae_of_measurable filter_upwards have rw apply congr exact


by_cases have rw intro exact have simp apply filter_upwards simp simp have have have have refine tendsto_Lp_finite_of_tendstoInMeasure rw apply apply exact ext simp


conv_lhs let change have intro simp simp


rw constructor intro simpa intro ext simp_all


rcases simp rw map_mul] congr simp rw exact


rw simp intro induction h b have simp_all contrapose use simp_all simp


refine rintro rcases induction zero succ use simpa rintro simpa


have refine rintro simpa have ext by_cases simp_all simp_all rw exact


rw intro induction simp_all rcases refine funext simpa


rw intro induction x simp_all rcases have have refine intro calc simp simp abel simp intro have simp_all rw intro induction induction apply simp symm simp use ext simp


obtain have simp use intro simp this, simp_rw exact


classical suffices have obtain use rw rw field_simp intro let have rw have rcases use simpa


have rw exact have let obtain obtain obtain have rw refine rintro simp rw exact replace rw replace simp rw this] apply rw congr exact intro rw rw exact


ext change dsimp rw simp pow_succ rcongr


rw rintro choose have refine simpa sum_mapDomain_index_inj simp


rw intro rcases mapRange_surjective let let use apply change d₂₁ simpa add_smul,


symm apply rintro use simp rintro induction zero single_add simpa


constructor rintro use simp_all rintro use simp_all


let letI letI have have set have apply simp refine exact


refine contrapose infer_instance refine rw exact


let let refine suffices have rwa have apply_fun exact


obtain let let have ext simp have simp apply exact exact exact


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


constructor intro exact intro induction base succ trans exact refine


intro choose refine intro rw mkQ_apply, ext simp


constructor refine ext simpa intro rw ext simp refine rw simpa


constructor refine let obtain refine simp rw simp intro choose obtain use ext simpa


intro rw intro rw let have intro simp rw apply intro rw exact obtain rw use rw apply intro specialize rw rw suffices convert ring cases simp rw exact


obtain rw intro apply intro refine rw apply nth_rw rw exact


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


induction smul obtain use simp rw exact add obtain obtain use simp exact


intro suffices obtain use ext simp let induction zero use apply_fun exact succ xn choose exact exact


let let change have simp rfl have apply rwa


refine by_contra rcases absurd simp have induction zero absurd exact succ by_cases let let simpa apply simpa choose let have simpa have by_cases simp rw nth_rw simp rw simp rcases have by_cases apply simp rw have simp simp simp apply use exact


have have simp constructor intro refine have simpa choose obtain use suffices refine have rwa intro obtain refine obtain simpa simpa


rw intro rw by_cases exact contrapose rw apply rwa


have refine rw intro have ext simp rfl simp rw natDegree_C, apply have exact exact rwa


AdjoinRoot.powerBasisAux

let have rw rwa have apply rw exact rintro rw apply obtain use rw rfl


induction h by_cases obtain exact obtain simp have have have have obtain simp) hqm algebraize refine rw exact


apply simp rintro let have mem_adjoin_of_map_mul have mem_adjoin_of_map_mul replace replace simpa


change rw rcases choose use intro rw refine intro have dsimp rw smul_smul apply refine change rw apply


obtain obtain have rw change rw refine gcongr


by_cases obtain simpa wlog have rwa rw have rw show


rcases rcases refine rw intro change refine have rw exact exact have rw exact change rwa intro change rw change rw rcases have rw refine intro change have rw rcases have rw rw refine intro change rw refine exact


classical obtain refine simpa intro rw simpa


classical refine rw exact rw rcases obtain choose rw set haveI letI letI have have refine rw exact obtain rw exact


Algebra.adjoin.powerBasisAux

have have apply convert apply have rwa rintro have rw apply rw obtain use ext exact


intro nontriviality let have rw simp by_cases simp have rw letI exact rw simp refine replace rw map_smul] simp by_cases simp rw exact simp


nontriviality revert refine intro rw split_ifs exact exact intro rw exact


suffices ext change rw ext constructor rintro exact rintro exact


obtain obtain have simp_rw choose classical let have hf sum_mem smul_mem have span span span rw rintro rw exact rw exact rw exact rw exact smul_mem refine convert rw refine


classical rw linearCombination_smul] simpa


classical obtain rw ext rw dsimp split_ifs simp simp


AlgebraicIndependent.map

have have intro rw refine simp intro rw rw exact


let obtain rw obtain simp convert rintro rw obtain obtain simp


refine simp intro rw rintro rw rw aeval_X,


let haveI rw lift_max, refine mul_eq_left simp


by_cases exact by_cases exact rw haveI haveI haveI simp_rw rw refine calc gcongr rw exact


fconstructor rintro have rw exact intro use intro specialize have dsimp rw simpa


IsTranscendenceBasis.isAlgebraic

constructor intro rw intro have rintro exact have intro have rw exact rcases have simpa exact


let refine rw set let letI haveI have have exact


refine let let have have letI have have have have exact


cases rw rw set let rw rw change have have have set let refine rintro have have have refine adjoin_induction rintro exact exact exact


have have have have rw have have obtain cases have have rw rwa obtain classical convert simp simp have refine rintro exact exact have rw matroid_isBase_iff, rw exact


classical refine suffices this.comp refine hfin.diff.induction_on_subset have convert x by_cases


set refine have rw intro rw refine simp_rw exact


obtain have h1 rwa leadingCoeff_eq_zero] exact


convert inv_eq_of_aeval_divX_ne_zero rw rw convert conv_rhs rw


obtain rw revert refine intro contradiction intro refine rwa intro rw rcases exact rw exact


have let dsimp have rw intro simp refine simp rwa


by_cases rw have exact have set have have integralNormalization_aeval_eq_zero exact


have refine apply_fun have rw leadingCoeff_C_mul_X] exact rw


by_cases on_goal exact have have cases have exact have refine rw exact


IsAlgebraic.restrictScalars

have by_cases on_goal exact rw have have have classical have let obtain exact have refine simpa smul_ne_zero_iff] rw eval_map_algebraMap, exact


IsAlgebraic.tmul

rw have refine rw map_aeval_eq_aeval_map


set set let let have have have have have rw intro by_cases exact exact have exact


classical rw refine have let have replace simp_rw let replace congr have have simp_rw simp_rw s.sum_erase_add exact eq_zero_of_ne_zero_of_mul_right_eq_zero


classical rw let replace let g let replace simp apply simp apply simp have have simp ext1 ext1 simp simp simpa


have let rwa isAlgebraic_ringHom_iff_of_comp_eq


refine obtain obtain simpa have simpa congr refine simpa


intro obtain have simpa have rw rw simpa


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


apply refine intro refine intro obtain suffices apply intro rwa intro rfl


rsuffices use rintro cases apply exact obtain refine simpa


obtain refine simp_rw intro rsuffices exact simp_rw mem_range exact


refine obtain replace rw convert simp rw exact consider


intro obtain rsuffices exact obtain use rw apply_fun simp rw


classical constructor intro intro constructor apply exact rintro


induction zero succ ih rw ascPochhammer_succ_left, smeval_C] simp


induction zero succ ih rw smeval_natCast, by_cases simp rw


induction zero succ ih rw sum_antidiagonal_choose_succ_mul sum_add_distrib, refine intro have refine exact rw mul_assoc simp have simp rw abel_nf rw


refine dsimp rw exact exact not_isUnit_of_not_isUnit_dvd obtain rw exact rintro exact


rcases refine exact obtain cases exact simpa


rcases contradiction obtain refine rw rintro exact obtain cases refine not_irreducible_of_not_unit_dvdNotUnit hp.irreducible simpa refine simpa


classical have intro obtain exact rw exact


classical let have apply intro refine eq_second_of_chain_of_prime_dvd have have rw rw refine have conv_rhs cases contradiction rw refine refine exact suffices simp apply simp rintro refine use rw exact exact


classical obtain convert refine calc n intro obtain have rw have rcases refine rwa rw exact


by_cases simp suffices rw apply obtain let have rw refine rw exact have suffices obtain use simp conv_rhs rw simpa rintro rw simpa exact


rw refine rw rintro exact have obtain rw letI letI suffices rw refine simp obtain rw exact irreducible_of_normalized_factor a simp


obtain exists_mem_normalizedFactors_of_dvd rw rwa


simp constructor exact refine rintro simp


rw constructor rintro rw exact rintro have simpa refine rw convert


rw any_goals constructor rintro rw rcases rw exact rintro exact


ClassGroup.equiv

haveI ext simp constructor rintro refine simp canonicalEquiv_spanSingleton] rfl rintro refine simp canonicalEquiv_spanSingleton] rfl simp canonicalEquiv_canonicalEquiv, exact


refine simp constructor rintro refine rintro simpa rintro refine simpa


refine rintro obtain refine rintro rw exact rintro have refine contrapose rwa exact


rw simp refine intro obtain have apply simp refine intro simp


constructor rw rintro have refine by_cases rw exact


classical rw rintro induction empty simp cons ih simp obtain specialize rw refine simp rintro replace simp_rw have calc simp_rw simp_rw apply replace by_contra have rw have mul_left_injective₀ obtain contradiction simp_all


cases rw trans simp constructor rintro exact intro obtain rw subst simp exact rw


rw obtain rw rw have intro rw refine rw exact refine rw apply simp rfl refine rintro rw exact exact intro exact


apply intro obtain obtain have simp suffices rw obtain use refine rfl⟩ rw exact refine obtain have apply simp rw rwa rw apply


refine have intro induction of refl symm trans add rcases rcases exact mul rcases rcases exact


haveI rw refine simp refine simp simp intro rw constructor rintro rw refine have rw intro specialize rw intro apply rintro exact have simp intro exact rw convert rename_i rw by_cases rw rw rw rw refine refine have simp apply rintro exact have simp exact rintro obtain have rw obtain refine simp intro rw exact have simp intro rcases exact exact dsimp rw rw rw congr apply intro rw rintro exact


constructor rintro refine rwa rw intro exact


classical induction empty insert rw refine refine exact exact refine simp


induction singleton cons rw have rw exact constructor rintro rw refine rw sum_pi_single', rw intro convert by_cases rw rw convert rw erase_insert have exact rw intro rw congr rw congr rw rintro obtain obtain use have rw rw simp rw intro rw rw congr rw congr rw


classical exact intro rw have refine rintro exact simp


refine rw obtain exact rintro apply grind


classical simp by_cases rw by_cases rw rw


classical by_cases rw order by_cases rw order by_cases rw rw simp set min have rw exact exact have rw exact exact have rw exact rw exact exact


classical by_cases simp rw have rw exact exact


classical have have rw exact obtain have rw intro rw exact use rw apply rw rw rw rw exact


refine contrapose have have have rw simpa


obtain obtain obtain simp have suffices obtain use rw exact classical have rw rintro obtain have rw specialize simp_rw simpa


by_cases use simp rw obtain have simp have refine simp exact


have have simp 𝔭.valuation_div_le_one_iff


classical split_ifs rw exact simp forall_apply_eq_imp_iff, obtain simp_rw contrapose obtain simpa


change traceDual rw ext simp apply simp refine rw swap ext exact simp


have have have rw rw apply intro rw refine apply rw apply intro rw split rw rw apply have rw exact exact


obtain suffices intro rw exact rw intro apply apply dsimp convert ext exact exact


rw intro rw apply apply rw have rw exact


simp forall_exists_index, intro obtain obtain use simpa smul_comm


have ext rw have apply ext simp rw have have have simp rw congr refine congr ext simp


have isSeparable_tower_top_of_isSeparable have isSeparable_tower_bot_of_isSeparable haveI haveI haveI rw coeIdeal_differentIdeal rw mul_inv, exact


classical have let have have have have rw congr have rw simp simp exact clear_value conv_lhs rw change simp apply rintro rintro by_cases exact rw exact rw exact


obtain have have have rintro rwa have obtain apply_fun apply_fun simp conv_lhs rw exact suffices have apply simp rw rw intro rw rw div_self simp intro obtain obtain have rw exact rwa intro rw refine rw exact


by_cases subst simp obtain rw exact obtain simp letI rw exact let let have have rw intro replace replace rw replace simp apply suffices obtain rw exact refine rintro induction mem obtain obtain simp refine rw zero add simp exact smul simpa simp exact


letI rw exact have have letI commutes obtain simpa obtain refine simpa rw simpa


have constructor refine simpa rw exact exact


obtain by_cases simpa let let have have have rintro rwa suffices have apply simp rw rw intro rw rw div_self simp intro obtain obtain have rw exact rwa intro rw letI have have have rw letI commutes have rw


classical rcases simp_rw simp let let have convert ext refine have refine have have have constructor intro rw constructor suffices contrapose exact rw apply simp contrapose rw apply simpa intro obtain rw obtain exact


IsLocalization.isDedekindDomain

have rintro exact letI haveI haveI refine infer_instance exact exact intro obtain obtain refine rw rfl


have have rw intro have obtain have have rw exact


classical rw split_ifs rw intro apply exact


have have have have simp rw simp rw rw apply


rw classical apply apply apply intro obtain rw rw apply


have have have have rw simp_rw rw apply intro rw


have map_ne_zero_of_mem_nonZeroDivisors have rw exact have rw apply rw exact


set set have have have have have have rw exact have rw rw exact have rw coeIdeal_span_singleton, rw coeIdeal_injective rw rw exact rw rw


classical have obtain have rw have obtain have rw have have rw spanSingleton_mul_spanSingleton, rw count_well_defined push_cast ring


classical induction empty insert hrec have have have rw


induction zero succ classical by_cases have rw rw ring


have rw have have have classical rw pow_one simp rw exact


apply exact intro classical by_cases rw rw intro rw


by_cases exact have rw obtain rw exact exact


have have have intro have by_contra rw push_neg rw rw exact exact h_subset


classical obtain simp obtain suffices obtain exact let have intro conv_rhs rw refine rw exact rw exact choose obtain rw exact refine by_contra obtain let have have replace have refine rw refine exact apply have simp have rw rintro by_cases subst convert rw refine exact


wlog obtain use simpa subst have rw simp ring_nf gcongr obtain refine refine simp simp mul_eq_zero, rw simp_rw


FractionalIdeal.quotientEquiv

haveI have rwa rintro exact refine intro refine exact rw refine intro refine simp exact rw by_cases obtain obtain exact rw inv_mul_cancel_left₀ rw refine intro rw convert simp have ext simp rw inf_eq_right.mpr] exact exact exact


classical have rw let rw let refine simp intro simpa


obtain have suffices apply intro apply_fun simp rw have contrapose rw exact simp_rw apply simpa


by_cases simp have simp constructor contrapose simp intro exact intro rw intro rw exact


IsDedekindDomainInv.integrallyClosed

let h.commGroupWithZero refine rw exact exact


IsDedekindDomainInv.dimensionLEOne

let constructor rintro refine have have suffices rw calc simp intro have obtain obtain have rw obtain rw exact


obtain obtain wellFounded_lt.has_min obtain hM.isPrime.multiset_prod_le.mp obtain classical have obtain rwa have subst refine convert rw refine exact


have letI wlog rcases have refine simpa have obtain replace let have have obtain obtain have refine exact rintro obtain rw have apply rw exact rw rcases rw apply refine rintro rw have contradiction


obtain le_one_iff_exists_coeIdeal.mp by_cases subst refine rw exact by_cases rw exact


apply by_cases rw intro suffices rwa rw have intro rw rw simp intro exact hx refine isNoetherian_submodule.mp obtain rw refine clear induction zero succ


rw and_congr_right_iff, intro refine exact


refine have have have have rw normalizedFactors_irreducible rw normalizedFactors_irreducible all_goals


let have spanFinset_ne_zero.mpr suffices obtain rw refine exact contrapose refine rintro rw intro intro rw refine rw exact


by_cases simp refine have obtain grw rw exact exact


letI have rw rw exact rw simp have rw rw simp rw exact rw


rcases have obtain exact rw factors_eq_normalizedFactors,


apply mul_left_injective₀ have simp coeIdeal_span_singleton] rw mul_inf₀ simp convert


have normalizedFactors apply intro rw exact have prime_of_normalized_factor apply rw constructor rw exact rw exact rw intro rw exact intro rw exact exact exact


use constructor refine have exact nth_rw rw


rw constructor rintro exact rintro exact


ext rw constructor on_goal rcases exact all_goals exact exact


idealFactorsEquivOfQuotEquiv

have have refine have simp rw have simp rw


cases by_cases simp by_cases exact rw exact


replace have simpa apply all_goals rw simp rw lia


have classical rw exact exact simp exact simp rw exact simp aesop exact simp


obtain apply contrapose obtain use rw ring


simp by_cases simpa obtain rw refine exact


letI revert refine simp intro specialize ih coprime rw refine intro obtain haveI haveI refine exact refine exact exact


by_cases rw rw exact suffices obtain exists_mem_normalizedFactors_of_dvd rwa by_contra exact rw exact by_contra exact


by_cases rw apply rw exact apply apply suffices rw exact rw exact


refine exact refine rintro rw exact rintro have have exists_mem_normalizedFactors_of_dvd obtain use simp exact


let have let let algebraize have have have have have apply apply ext simp rw algebraMap_apply simp rw


IsIntegralClosure.isLocalization

haveI haveI haveI refine rintro rw map_ne_zero_iff exact obtain obtain refine rw simp


letI let let obtain have refine rw exact refine bs'.map y) toFun invFun left_inv right_inv intro intro rintro simp simp exact


IsIntegralClosure.isNoetherian

haveI obtain let letI let refine rw exact


intro have simpa let let have rw intro rw refine rw exact have refine rw map_mul, rwa traceDual_span_of_basis


have refine ext exact rw extendedHomₐ_coeIdeal_eq_map inv_inv, have rwa exact


have refine ext exact suffices apply refine rw exact exact have rwa extendedHomₐ_coeIdeal_eq_map coe_extendedHomₐ_eq_span, simp rw rw exact


letI have rintro exact by_cases subst rwa have have refine associated_iff_eq.mp rwa simp intro split_ifs subst refine assumption by_cases refine exact exact hQp


have set have rw apply grw have rw exact obtain refine rw refine conv_rhs grw rw exact


have rw let haveI have simp_rw rintro exact have left_lt_sup.1 have intro obtain exact choose choose let have refine obtain replace have intro obtain exact have obtain refine have rwa simp_rw rw refine obtain rw rw obtain rw exact refine rw obtain rw specialize simp_rw exact


letI letI refine rw exact and_iff_right_of_imp or_iff_not_imp_left.mpr


classical rw rw change simp_rw if_neg valuationOfNeZeroToFun,


rw constructor exact obtain change apply_fun rw rw gcongr exact


ext constructor intro by_cases exact exact exact


ext constructor intro rcases have have rw rw rcases rcases rw rw rw exact simpa rintro rw exact


induction zero succ rcases simp have simp add_zero,


by_cases simp by_cases simp rcases rw simp rw congr lia rw trans ring_nf rw congr norm_cast lia


let apply rw simp apply conv simp apply rw simp p]


derivationToSquareZeroOfLift

refine diffToIdealOfQuotientCompEq map_one_eq_zero leibniz rw ext intro let have rw convert ext dsimp simp rw simp ring


have refine intro by_contra rw rcases rcases rw apply apply exact


constructor intro rcases constructor assumption use constructor exact rintro obtain have rintro apply simp rw replace rw exact rintro haveI refine rcases have order


rcases suffices clear intro obtain have rcases obtain clear revert decide simp simpa obtain rw rcases exact rw exact


obtain refine intro obtain refine have rw rw congr symm rw simp rintro rw apply


classical constructor intro by_cases rw use simp obtain obtain have obtain refine simpa constructor use change apply intro by_cases simp obtain simp apply apply simpa rw exact


rw haveI obtain refine rw exact rwa intro rw rintro apply apply rw rwa


have obtain use have rw rw congr rw simp rintro rw refine apply assumption


have rw assumption rcases use have rw use


have rw refine simp rw have refine all_goals intro obtain assumption simpa


have constructor contrapose intro obtain obtain rw nofun rintro exact


classical have constructor by_cases rw rw apply obtain rw emultiplicity_le_emultiplicity_iff] exact rw exact


unfold generalize generalize cases top coe cases top coe rw exact


by_cases let exact classical obtain by_cases use have have rintro apply simp have have intro obtain have intro exact clear induction empty cons rcases use rw exact obtain use rw exact have obtain obtain use rwa use apply change by_contra apply by_cases obtain rw apply apply exact rw exact


classical by_cases rw obtain have have rw apply exact refine rw have exact rcases have rw exact obtain exact have intro rw have let let let have by_cases have obtain refine apply rw rw exact apply have contrapose rintro obtain have rw exact obtain rw obtain rw exact refine apply intro rw rwa


classical obtain have ext have intro simp simp by_contra rw simp


rw simp_rw congr simp congr rw have simp_rw simp sum_add_distrib, rw have rw exact have have have rw infer_instance rw ring


let letI have refine rw exact have nodup_roots have intro rw repeat apply rw congr rw conv_rhs congr rfl ext rw rw refine prod_bij simp true_and, simpa exact rintro rw exact exact


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


induction smul hb rw hI.factorial_mul_dpow_eq_pow ring add hy rw apply intro rw


classical induction empty simp rw insert hrec rw mul_assoc] apply rw


simp induction empty simp by_cases rw rw simp rw apply rw exact insert have simp_rw sum_sigma', apply sum_bij simp simp intro apply intro simp exact intro simp rw apply apply intro apply conv_lhs exact intro convert rw


ext by_cases refine intro simp exact intro simpa rw


unfold by_cases rw simp cast_nonneg] have have simp exact rw simp rw gcongr exact_mod_cast simp apply conv_lhs gcongr norm_cast rwa


PadicInt.dividedPowers

classical refine ofInjective rw simp exact intro exact simp


rw simp rw apply intro rw ring_nf simp exact


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


have rw by_cases simp have rw apply rw inverse_mul_eq_iff_eq_mul inverse_pow_mul_eq_iff_eq_mul simp ring_nf


rw nth_rewrite congr have rw suffices apply rw simp


refine have rw hI.dpow_zero exact refine rw exact


refine have apply intro induction mem zero rw exact add rw apply intro by_cases exact exact smul rw exact


cases inr refine intro simp exact inl simp exact


refine conv_rhs rw dsimp rw have by_cases simp simp simp_rw rfl conv_rhs rw dsimp rw apply by_cases rw simp


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


set isSubideal dpow_mem simp apply have refine simp rw intro have simp rcases exacts rw rintro exact


constructor refine rw refine rw ext rw rw


refine refine have intro rcases exact rwa have intro obtain have rw have contrapose simp refine simp refine simp_rw intro simp_rw intro obtain obtain obtain rw exact


rcases lift exact rcases lift exact rw obtain obtain suffices rcases refine simp refine simp


constructor intro obtain exact constructor exact intro obtain exact intro exact


Algebra.EssFiniteType.aux

refine intro exact intro obtain refine rw exact rintro refine rw apply rintro refine rw exact


Algebra.EssFiniteType.comp

rw classical obtain obtain use simp intro obtain obtain obtain refine rw exact rw exact rw exact


Algebra.EssFiniteType.baseChange

classical rw obtain use intro induction zero tmul obtain have have rw apply simpa refine simp rw apply exact add obtain obtain refine rw exact


rw classical obtain use intro obtain simp_rw exact


suffices apply suffices exact apply exact rintro


have have refine refine intro let obtain have have rw obtain have f rw obtain use rw use apply simp rw eval_map_algebraMap, exact rw apply rw


refine refine intro have intro have have have have exact choose have intro have rw rintro exact rw rfl apply rw simp have intro have apply intro have obtain apply_fun rw simp have have exact refine change intro obtain simp rfl change intro obtain simp rfl intro change rw ext simpa


classical constructor intro have have have letI let let have rw exact intro rw exact


constructor intro obtain have exact inferInstance⟩⟩ intro choose have refine exact


letI haveI haveI letI trans simp change rw simp


refine constructor rw intro apply apply simp rw change congr ext simp intro have obtain apply rw have ext simp exact refine change congr ext


letI letI letI letI intro obtain obtain obtain refine simp rw simp) letI toRingHom_algebraMap algebraMap_toRingHom haveI haveI haveI haveI letI letI letI haveI haveI haveI rw convert exact refine exact let refine have rw ext obtain simp have rw rfl simp have rw exact


ext simp simp letI letI letI letI intro obtain obtain obtain refine simp rw simp) letI toRingHom_algebraMap algebraMap_toRingHom have ext change simp exact rw


have obtain rintro have have rw simp_all refine have simp have have f.toRingHom intro obtain suffices simpa have simpa simp obtain obtain have simp_rw refine simp convert refine simp algebraize have refine exact


have obtain obtain simp_rw obtain apply_fun simp obtain refine convert_to linear_combination exact have have refine rw rw exact rintro rw have grind


StandardEtalePair.instFormallyEtaleRing

refine rw suffices simpa intro obtain exact


StandardEtalePair.equivAwayQuotient

refine rw rw exact change simpa change simpa apply ext simp ext


ext induction zero add tmul obtain induction zero add tmul simp


letI have rw refine simp algebraMap_toRingHom, convert simp ring


Algebra.Extension.Hom.sub

letI haveI letI haveI haveI show rw refine refine map_one_eq_zero leibniz ext simp intro ext simp exact


ext induction zero add tmul obtain induction zero add tmul simp tmul_sub,


ext obtain simp one_smul, apply ext simp


let have suffices rw have have rw exact exact


refine refine convert ext exact simp suffices rw exact


simp_rw congr have dsimp rw exact rw rw simp


cases let relation span_range_relation_eq_ker have exact classical choose let let have rw apply convert simp have suffices obtain let exact rw simp rw dsimp simp refine rw convert exact


cases let relation span_range_relation_eq_ker have exact have exact


rw set let have simp exact apply exact simp apply rw simpa exact simpa


refine simp_rw exact apply simp_rw exact


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


set algebraize let let refine obtain suffices rw obtain rw use dsimp rw simp rw simpa rw apply simpa


Algebra.Generators.baseChange

apply intro induction zero tmul let use simp have intro induction rw add mul_X rw add obtain obtain use rw


intro induction use simp simp_rw simp add obtain obtain use simp mul_X obtain use simp


letI apply rw rintro have simp rw rintro let suffices simpa rw refine convert_to monomial rw refine obtain obtain clear have monomial toComp_toAlgHom_monomial simp rw apply refine simp rw clear have rw intro obtain simp_all rw induction monomial rw obtain conv_rhs simp classical simp rw simp split simp congr add simp rw refine convert refine convert


Algebra.Generators.kerCompPreimage

refine refine exacts simp conv_rhs simp map_one, congr simp_rw


conv_rhs rw refine simp rw rw simp congr rw simp


ext rw constructor rintro simp rw intro exact


have aeval ext simp rw rw simp change simp


apply rw intro have apply_fun rw simp erw change rw rfl intro rw have let have rw clear induction simp rw simp add mul_X rw replace rw convert simp


simp simp conv_rhs congr ext simp rw simp


ext constructor rintro exact rintro use simp


classical simp sub_eq_add_neg, refine simp simp simp


classical cases simp jacobian_eq_jacobiMatrix_det,


rw rw congr ext simp rw simp generalize induction add mul_X simp simp


classical cases cases rw convert_to simp congr convert rw


classical cases simp_rw have ext simp rw apply


classical cases cases simp_rw simp simp_rw simp


obtain use intro induction zero succ rw exact simp


apply rw rintro rw split_ifs rwa exact intro rw apply rintro exact


rw constructor intro refine intro obtain replace dsimp rw rw apply rintro dsimp rw have have rw exact let intro have induction zero succ by_cases exact simp rw rintro refine rw exact rw exact


classical delta simp_rw constructor rintro refine intro rw intro refine refine exact dsimp rw congr ext simp constructor rintro rintro rintro rw simp_rw apply rintro obtain have rw exact


let have inf_eq_right.mpr constructor obtain obtain have rw exact intro exact rintro rw intro induction zero succ rw exact


constructor intro by_cases refine rw apply rintro rintro


rw intro by_contra have obtain have exact


Algebra.FinitePresentation.equiv

obtain use constructor rw exact suffices rw exact have have have rw rw


Algebra.FinitePresentation.iff

constructor rintro exact rintro letI exact


constructor rintro set refine simpa rintro have use refine simpa


have rw classical obtain let cases refine rw exact rw exact


classical obtain letI letI refine rw exact obtain have choose have rw refine rw apply rw letI refine rw let let change have rw rintro rw have rwa rw sub_self] apply intro rw let change have have rw refine rintro rw add_comm] apply exact apply apply exact apply exact intro apply exact intro exact intro obtain obtain rw apply exact refine obtain rw add_zero] suffices refine rw exact rw intro apply apply exact


classical obtain let let have choose have choose let let refine simp have intro rw simp_rw rw let have rw rintro change rw change rw change rw exact apply intro have have rw trivial refine rintro rw apply exact apply apply exact intro apply exact intro exact intro obtain obtain rw apply exact exact obtain refine simp add_zero, suffices apply rwa rw intro apply apply exact


letI obtain let change change have clear_value subst clear induction zero refine rw convert simp exact succ let have rw convert exact have convert rw congr simp


Algebra.FinitePresentation.baseChange

obtain let have have have rw exact let refine simp_all change simp exact simpa


obtain refine have apply simp exact exact


constructor rintro refine rw rintro exact


constructor rintro use intro have rw simp_rw exact rintro exact


constructor rw rintro use rintro letI exact


constructor rw rintro have exact rintro exact


Algebra.FiniteType.isNoetherianRing

obtain apply isNoetherianRing_of_surjective rw rfl


intro induction hM have refine exact exact rintro exact hadd rcases rcases exact hsmul rcases exact


intro induction hM have refine exact exact rintro exact hadd rcases exact hsmul rcases exact


classical obtain induction empty rw exact insert rw exact


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


classical let span have constructor rintro rw apply exact intro rw have rw obtain have suffices rw exact obtain rw eq_comm] exact


letI letI haveI let commutes haveI exact


rw constructor rintro obtain exact rintro exact


constructor intro obtain refine convert ext simp rintro have exact


unfold constructor intro obtain refine apply rwa rw exact intro exact


haveI haveI haveI obtain obtain have intro have rw exact rcases exact have choose exists intro constructor simp apply simp apply obtain clear exists rw apply refine intro exact intro have rw exact intro have rw exact rw rcases refine mem_sup.2 x rw refine haveI rw refine rfl rw constructor apply rw refine intro exact exact exact rw rw rw rw refine unfold rw exact exact


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


revert apply intro simp obtain refine intro obtain obtain use exact


classical obtain suffices obtain have have rwa use clear induction empty insert obtain have have have algebraize refine simp exact


classical obtain letI have have have exact


rw rcases have refine rw exact rw intro rw change rw exact rw clear induction empty rcases refine specialize rwa apply rcases rw rw have specialize rw rcases dsimp rw rcases use constructor rw exact rw exact rcases refine simpa intro specialize rw rcases dsimp rw rcases simp rw exact


refine rcases choose use ext have induction mem zero add smul


rw refine obtain exact choose suffices exact


have let generalize suffices obtain let exact intro induction zero succ let have have refine simpa have have exact let refine refine rw simpa convert suffices simpa apply simpa


refine rcases apply rw intro simp rcases have refine rw simp rw rw intro rw apply_fun simp replace rw norm_num intro simp rcases exact exact


let let suffices rw exact exact1.comp_injective exact


by_contra obtain obtain have obtain have simp_rw exact tauto


let refine have have have have have have have convert dsimp congr ext change simp


let let let let e₃ let map_smul x dsimp induction zero add tmul induction zero add tmul induction zero add tmul rw ext1 dsimp change rw exact


classical tfae_have tfae_have tfae_have tfae_have h₄, let let have calc obtain use use use constructor apply intro simpa ext simp exact tfae_have h₅, let let have obtain refine simpa simp_rw smul_eq_mul, simpa tfae_finish


have x revert apply intro have simpa intro obtain have obtain use simp_rw exact convert simp


have haveI have simp_rw obtain use apply apply simpa


refine obtain have rw exact m'.isPrime.ne_top


refine have rw exact intro rw rw apply have simp simp


obtain let by_cases rw contradiction let simpa have eq_bot_iff.2 intro induction h simpa have refine rw exact


refine intro specialize haveI have refine rwa


Module.FaithfullyFlat.directSum

classical rw refine obtain obtain haveI apply


rintro rw by_contra let have have ex.apply_apply_eq_zero have ext simp have rw obtain choose let have refine show rw have subsingleton_iff_forall_eq show eq0 exact


constructor rintro intro let suffices rw ext apply_fun rw simpa


refine intro rw rintro obtain rintro apply have have apply rw rw refine rw convert ext simp


constructor intro refine intro rw exact rw exact intro rw exact ext constructor rintro rwa intro obtain exact rintro rw apply


refine coeToSubmodule_injective span_induction rintro rw exact rintro exact


obtain intro simp rw obtain refine obtain have rw exact exact


apply simp apply rintro obtain rw exact add_mem rintro suffices exact hy.elim


apply simp refine rcases replace rw refine rcases exact exact rw exact rcases exact


contrapose rw obtain refine simpa subset_span contrapose rw exact


constructor intro apply rw intro apply rw intro have rw contradiction


rw replace have dsimp rw rw simp_rw rw exact all_goals


have let let rw change rw show b₀.toMatrix ext simp_rw rfl] rw show mul_div_cancel₀ rw exact


have obtain rw rw simp_rw rw mul_div_cancel₀ rw exact ext simp_rw


obtain have obtain refine rw exact rw exact


rw ext constructor simpa apply rintro convert rw


have suffices congr_arg apply apply intro rw exact rw gcongr apply intro rw exact


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


ext refine constructor rintro obtain use rw rintro refine rw


apply intro constructor rw obtain obtain use rw rw obtain use use simp


constructor intro refine intro obtain use rw rintro exact rintro exact


have rw spanSingleton_one] let have refine rw spanSingleton_mul_spanSingleton,


rw by_cases simp have apply intro rw specialize have rw exact rw inv_mul_cancel₀


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


FractionalIdeal.isPrincipal

obtain use suffices rw exact conv_lhs rw


simp constructor intro exact rintro rw exact


classical by_cases rw exact have mt have rw intro rw obtain use rw spanSingleton_mul_spanSingleton,


funext dsimp rw apply simp exact rw conv_lhs rfl


have congr rw intro obtain simp rw simp simp


let have have obtain have cases obtain have have let commutes r dsimp rw obtain refine rw exact


classical obtain let let refine rw intro rw exact


obtain choose refine rw rintro by_cases exact exact


refine rcases obtain obtain rw obtain have exact refine rw simp


obtain apply rintro simp by_cases refine rw rw rw exact


have algebraMap rw exact simp rw subst rfl


rintro obtain use simp apply exact rw apply exact


letI constructor rintro rw let convert ring refine ext simp rw use simp ring intro obtain rcases contradiction let convert refine ext simp rw exact intro obtain obtain replace simp obtain refine ext simp refine rcases contradiction subst convert


by_cases exact rw rintro obtain by_cases exact have simp_rw clear have rw trivial induction mem obtain clear by_cases apply refine exact ext simp congr refine exact convert ext have refine exact simp zero convert ext add convert ext smul convert ext simp coe_decompose_mul_of_left_mem_zero


rw change rw rintro have rw conv simp_rw simp have apply simp simp congr ext congr exact simp rw rcases simp rw simp_rw gcongr exact rw apply apply refine rcases have simp exact apply classical rintro apply apply refine simp aesop ext simp


classical let have swap rw intro rcases exact exact rw apply rintro refine simpa simp congr change simp


HomogeneousLocalization.Away.finiteType

constructor obtain choose simp_rw rcases let refine rw rintro obtain simp convert ext simp refine let let let apply rintro refine rw simp_rw gcongr exact


classical rw apply intro obtain have rw split_ifs exact exact


rintro rw rw obtain rw refine rintro rw refine rcases apply exact


Ideal.IsHomogeneous.iSup

simp_rw choose refine simp_rw congr exact


refine apply have convert ext rw refine rintro exact


intro classical rw refine intro apply use use


refine classical refine by_cases classical exact


Ideal.IsPrime.homogeneousCore

apply exact rintro have refine exact exact


rw apply exact refine rintro refine refine exact


classical obtain simp simp leadingCoeff_of_ne_zero, simp


have let have rw exact have rw exact exact


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


refine have rw have rw simp untop_orderTop_of_ne_zero rwa


rw dsimp by_cases rw exact rw contrapose obtain rwa


obtain simp rw apply simpa intro obtain rw apply simpa


obtain simp refine constructor exact hsum_orderTop_of_le coeff_eq_zero_of_lt_orderTop have rw refine intro exact intro exact


simp rw coeff_single_same intro rw contrapose apply by_cases


by_cases simp intro have refine simpa simp obtain simp use simp rw pow_add, simp simp intro by_cases have simp use simp simp


by_cases ext simp rw simp rw refine intro simp and_true] use simp_all intro have intro contrapose simp exact simp rw exact simp hsum_mul] rw


rw simp intro simp refine by_cases refine simp simp


let have have obtain let have have mk let have have rw simp refine intro simp_rw cases top coe


rw constructor intro have have refine intro simpa intro have apply simpa intro contrapose simpa have have have rw simpa


constructor obtain exact exact obtain simp exact


simp_rw obtain simp_all have have constructor intro refine have obtain simp_rw simp_rw rw simp_rw obtain have simp convert exact intro refine refine intro trans apply simpa suffices apply simpa rw suffices simp_rw rw convert refine rwa


obtain simpa simpa simp_rw refine intro contrapose rw have apply simpa exact


ext have rw simp_all rw simp_all intro simp_all contrapose intro rw


ext have rw simp_all rw simp intro simp_all ne_eq, contrapose intro rw


by_cases simp_all simp by_cases simp rw ext simp rintro rw exact trans apply ext simp constructor rintro exact rintro exact simp


apply exact exact intro simp contrapose simp


by_cases by_cases have rw by_cases rw exact rw exact


ext simp refine simp_all exact simp_all by_cases exact exact


by_cases simp simp by_cases simp rw ext simp rintro rw exact trans apply ext simp constructor rintro exact rintro simp simp


by_cases by_cases have have rw refine rw exact


have have have refine le_antisymm rw order_of_ne exact


induction zero simp by_cases simp have simp succ rw calc n


constructor intro constructor rw exact rw exact intro refine lt_of_le_of_ne rw


ext rw coeff_smul_right simp apply aesop


ext by_cases rw simp rw simp_rw rintro rw exact


ext by_cases obtain simp trans simp apply rintro simp obtain simp rintro contrapose obtain obtain simp simp exact rw contrapose obtain obtain obtain exact


ext simp split_ifs subst convert rw simp intro simp


ext simp split_ifs rw convert rw simp intro simp


have rw have by_contra simp simp simp rw


apply have support intro refine simp contrapose rw refine simp_all exact


apply exact simp obtain simp exact hij.2⟩


rw simp simp_rw rw refine rw refine have simp_all coeff_support, exact


ext simp simp_rw rw intro simp contrapose simp


intro induction zero simp simp exact succ obtain exact


have by_cases by_cases swap apply intro refine hy obtain exact lt_add_of_pos_left lt_of_lt_of_le rintro exact obtain refine simp exact


let by_cases have simp have have rw refine rw exact rw exact


obtain exact refine rw exact have rw rw exact


constructor rintro refine rw rw rintro rw rw have rw exact


constructor intro have rw obtain obtain use rw exact obtain obtain rw specialize have exact


HenselianLocalRing.TFAE

tfae_have tfae_have constructor intro specialize have simp obtain refine rw rwa tfae_have hR, obtain have simp obtain contrapose rwa refine rwa tfae_finish


IsSemiprimaryRing.induction

have set replace have rw intro let have exact induction zero succ obtain rw refine rwa rw exact


refine let have simp_rw exact let have have exact


obtain rw rw rw have rw let rw refine rw infer_instance infer_instance


refine obtain exact rintro refine exact intro exact


constructor intro refine ext constructor rcases refine rcases exact exact rintro refine rintro exact


constructor intro rcases rcases exact rintro refine exact


obtain set_has_maximal_iff_noetherian.mpr refine intro rw intro rw have intro rw rw rwa


rintro by_cases obtain left refine rw rw apply_fun rw rw apply_fun rw contrapose exact right refine rw rw rw rw obtain by_contra exact


obtain have rintro apply rwa obtain replace intro rw apply intro exact rw intro exact


ext rw refine rintro haveI refine rw exact obtain exact


refine rintro have obtain obtain have have refine


have exact obtain suffices replace rw exact intro induction zero change rw exact succ specialize obtain replace exact exact


associatedPrimes.finite

induction subsingleton quotient have simp exact


rcases constructor refine by_contra simp use ext rcases rw refine use simp have rw simp rw exact have rw have rw simp simpa


rcases rcases rcases simp have simp choose refine rw intro simp obtain rw exact simp have simpa hr] have have tauto


simp_rw apply intro apply by_cases rw exact refine lia


induction empty cons simp add_pow] refine intro rw by_cases refine rw simp_rw rw use simp_rw refine replace have rw rw simp_rw exact


rw rcases obtain rw trivial exact rw rcases simp smul_eq_mul] have rw refine rintro simp_rw rcases have rw exact refine rw exact


rw rintro induction zero add single rw exact


refine let bot_isMaximal, by_contra obtain exact


Ideal.cotangentEquivIdeal

refine rw rintro replace obtain obtain rw dsimp rwa rintro exact


Ideal.mapCotangent

refine exact intro rw refine rintro simp convert ext exact


induction singleton use simp ext simpa cons simp obtain have constructor rw have rw rwa obtain use simp exact


refine intro rw obtain refine ext exact have obtain refine simpa


refine intro contradiction intro refine simp intro rw obtain refine simp simpa


obtain have have have have convert exact obtain rw refine simpa simp


refine haveI exact isField_of_isIntegral_of_isField


have rintro exact let let letI obtain let have have refine convert rw rfl


obtain refine rw refine rw exact refine simpa


constructor rintro contrapose intro obtain let have obtain rw exact


rw by_cases rw exact rw refine haveI have exact


let obtain refine trans rw exact norm_cast exact


rw simp constructor intro refine by_contra exact rintro exact


obtain simp exact haveI primeHeight_eq_zero_iff.mpr


have intro simp exact obtain rcases have have simp exact


rw constructor intro exact intro obtain exact


let have have simp_rw have ringKrullDim_eq_of_ringEquiv rw exact


induction zero refine rw exact succ obtain let have have refine rintro rw exact push_neg intro have rw rw norm_cast exact simp_rw obtain refine rwa apply push_cast exact refine have by_cases rw exact have have suffices push_cast have rw exact intro apply have apply rwa rwa refine rwa exact


apply rw refine by_cases simp simp refine rw apply exact exact apply exact exact


rw apply exact refine by_cases exact obtain refine exact


rw apply exact refine obtain exact obtain exact


simp_rw nontriviality rw refine rw rw exact


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


constructor intro obtain simp apply rintro simp rintro


by_cases have refine intro rw rw exact rw have refine by_contra have rw exact


cases have have simp_rw exact rw simp_rw exact rw exact


rw infer_instance refine have contrapose exact


rw constructor rintro exact intro by_cases rw add_le_iff, exact obtain rw exact


Ideal.quotEquivPowQuotPowSucc

let let have have let simp exact have ext simp constructor exact rw obtain rw rw exact contrapose rw let refine refine rintro rw refine simp


classical rw rintro induction h replace have cases zero rw simp_all succ wlog rw rw rw exact this obtain simp_rw intro obtain have rw exact obtain exact have rw exact by_contra hq hJ) have have rw exact obtain let suffices have hn) rw convert simp refine rw


obtain rw refine convert exact exact rintro exact


constructor intro obtain refine norm_cast rintro exact le_trans


obtain have refine rw refine rw exact convert_to symm simpa exact


classical let have obtain have have refine obtain exact obtain have let suffices refine norm_cast have rw exact grind refine rw refine convert simp


classical obtain let obtain have hP'.1.2 have refine obtain rw use rw obtain let suffices rw apply norm_cast refine rw refine have refine convert simp


refine obtain obtain let lq.map have simp refine refine rw simp conv_rhs refine simp obtain have rw apply simp


rw change rw intro rw intro by_cases simpa


refine have classical convert ext obtain simpa simp


constructor intro simp_rw exact rintro exact


refine suffices have rw rw exact refine ne_of_lt rw exact


rw constructor intro exact intro refine intro exact exact intro rw intro rw


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


refine replace rw exact refine rw rcases rw have convert abel exact


rw have convert refine rintro haveI exact rintro haveI exact


obtain rcases mem_span_insert.1 refine rwa


have exact cases exact refine have exact


set suffices obtain exact apply swap refine rintro refine rw exact rintro rw exact


rw ext refine refine simp exact refine simp exact


rw apply intro rw rintro obtain exact apply intro exact


constructor intro by_contra have have rw apply rintro exact


refine refine rw exact simp have rw refine convert exact have hJ.2 simpa


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


classical obtain have have refine rw exact


have refine rintro have rw apply apply exact exact


ext constructor intro obtain exact rintro exact


ext constructor intro haveI refine rintro have refine exact exact intro refine rw refine rintro exact intro rw haveI exact


by_contra obtain set_has_maximal_iff_noetherian.mpr simp have have obtain rw refine rcases exact exact


refine or_iff_not_imp_left.mpr or_iff_not_imp_right.mpr rintro exact exact rwa rw classical let have have have have push_neg have obtain exact have have exact


refine replace let have have obtain exact obtain exact exact hq.not_isUnit hp refine le_iSup_of_le le_rfl fin_cases exact simp_rw exact


have intro rw contradiction rcases use apply apply exact


suffices rw simp exact refine contrapose rw exact


induction zero succ have suffices rw card_quotient_mul_card_quotient choose choose choose refine rintro rw hf refine simpa intro refine have refine simp refine rw exact


let haveI exact have cardQuot_pow_of_prime cardQuot_mul_of_coprime


by_cases subst have have contradiction exact


rw by_cases simp let rw congr refine simp


constructor intro rw intro rw zero_dvd_iff, apply rwa rintro exact


obtain simp let refine suffices let refine exact rw simpa intro rw hJ.symm] congr


classical have have rw let refine intro simp_rw exact simp_rw conv_lhs enter rw and_iff_left_iff_imp.mpr rw


let let let let hM.trans algebraize have let have have apply apply rw let rw refine intro simp obtain refine simp apply_fun apply_fun simp rw apply simp rwa intro rw exact


refine rcases rw exact rw rcases rw rw exact


rw intro induction mem obtain exact zero add smul


nontriviality cases have simp refine by_cases subst rw intro exact have let simp rw spanNorm_singleton,


by_cases refine have rw have relNorm_mono rw obtain exact


let let have by_cases have have rw exact rw rwa obtain suffices have relNorm intro rw have have rw obtain rw have simp rwa mul_right_inj inertiaDegIn_eq_inertiaDeg rw exact


let obtain have have have rwa pow_left_inj] exact


have by_cases simp rw refine intro rw simp intro have rw have let let have have have have have rw inertiaDeg_algebra_tower


refine obtain refine intro obtain exact exact


constructor rintro exact refine rintro refine letI rw split_ifs assumption exact refine simp exact rintro refine simp rintro refine rw


classical exact s.induction_on top_unique rw refine simpa


rw apply intro by_cases exact refine lia


classical refine rw exact intro rw exact


rw constructor rintro rw apply rw simp intro refine simpa


suffices refine exact generalize induction zero clear rw subst rw simpa succ classical replace rcases replace by_cases obtain obtain have rw exact have have rwa exacts have rw rw simp rw exact specialize refine exact by_cases have rw exact specialize right rcases exact exact exact by_cases have rw exact specialize rcases exact exact exact by_cases exact have simp exact rcases by_cases specialize rcases order order right right exact exfalso rcases rw have rcases exact exact exact rw rcases simp exact


ext rw refine rintro classical refine rw apply intro rw exact


replace rintro simp obtain exact choose refine exact


apply rintro rw mem_map_iff_of_surjective refine rintro simpa


simp_rw obtain conv_lhs congr rw simp rw simp simp


constructor contrapose rw simp intro have rw exact simpa


constructor rw intro rcases right rw exact left rw exact rintro exact exact


apply constructor intro rcases exact intro rcases rw exact


have rw convert classical refine simpa rintro refine simpa simpa


suffices suffices constructor rw have exact let rw have have exact


classical cases rw gcongr change let rw have rw let have have refine simp


classical induction empty insert rw have have exact


have induction zero succ refine refine rw


obtain induction by_cases subst apply rw rcases rw haveI exact rcases rw exact apply apply rw apply exact apply rw


refine revert apply swap introv apply apply exact introv obtain have rw have rw exact have rw ring exact


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


classical cases intro choose have intro have intro exact rcases replace refine simp exact choose use ext rw simp intro simp


refine intro simp intro obtain simp intro obtain obtain simp intro rw obtain refine simp


ext refine rcases rw simp exact rcases simpa


have induction zero rw subst simp succ rw subst rw simp lia


ext refine rcases have rcases rw exact rcases simpa


rcases rcases rw apply rw rcases refine calc rw apply simpa


rw constructor rintro obtain exact rintro exact


have conv_rhs nth_rw rw simp rw exact simp refine simp exact rwa


obtain cases exact let have have have obtain refine rcases simp simp obtain apply_fun have rw rcases simp rw


cases obtain lift_of_isNilpotent_ker_aux refine


cases choose exact cases obtain simp rcases simpa obtain refine funext have cases zero succ


have simp simp abel obtain have induction rwa


suffices intro obtain obtain exact intro rw exact


classical refine rw intro simp suffices refine intro suffices obtain rw


let change rw apply intro fin_cases intro fin_cases simpa


have rw exact obtain use rw rcases rw simp


induction mem obtain simp algebraMap add mul rw refine obtain exact


cases use obtain let have refine exact simp refine simpa replace simp simp refine simp rw simp rw simp


classical let letI refine induction zero add mem obtain simpa smul simp refine exact


rw rintro have ext obtain simpa simp simp obtain obtain rw obtain simpa


have constructor intro let suffices obtain refine exact intro obtain simpa obtain obtain set by_contra have ext obtain simpa simp simp have simpa congr exact haQ by_cases have simp coeff_scaleRoots, refine simp


haveI haveI haveI haveI haveI apply rw apply ext exact


by_cases subsingleton replace let let have haveI have let letI have letI let letI have letI have have apply apply rw letI have have apply rw


by_cases subsingleton replace let let let letI have letI let letI have letI have have apply apply rw letI have apply rw


classical haveI by_cases exact let let let suffices obtain refine apply rw exact rw map_inv₀, norm_eq_prod_roots have rw inv_mul_cancel_left₀] refine exact replace suffices rw simp exact exact simp refine simp


AlgHom.isIntegrallyClosedIn

rintro refine convert aesop obtain aesop rintro apply simp_all


constructor rintro simp_all rintro refine rintro apply


refine constructor intro refine rintro apply intro rw exact


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


refine by_cases simpa let replace let have refine simp replace rw simp obtain refine rw


let let letI have have refine intro obtain obtain refine rw


ext rw constructor rintro exact intro use simp


by_cases use have rw exact use rw by_cases apply_fun rw rw exact rw rw suffices rw


have ext constructor simp intro obtain have nth_rw simp exact exact


rcases let have fg_adjoin_of_finite let have rw convert let let have refine rw letI have exact


obtain obtain refine rw exact refine induction h obtain exact have rw minpoly.monic rw simp_rw refine simp lia


obtain let change rw rintro obtain refine suffices algebraMap algebraMap simpa mul_left_comm] simp have have apply exact exact have rw exact exact


nontriviality have refine rcases exact rw rcases rw eval₂_sum, refine rw exact smul_mem


constructor letI letI exact have simp letI letI exact


constructor rcases refine rw rcases exact


classical intro rw refine exists_eq_pow_of_mul_eq_pow_of_coprime rw exact


classical obtain have rintro apply ext rw obtain rwa replace let calc show apply simpa exact show calc sum_nbij let rw norm_cast simp


replace letI refine replace rintro exact rw obtain have rw isIntegral_algebraMap_iff obtain rw exact


cases have intro rw intro suffices obtain apply obtain rw exact obtain obtain exact


obtain let have rw rintro exact obtain replace let obtain rw let let let have ext rw simp split_ifs rw rw have have rw replace rw rwa or_iff_right let have have intro have rw zero_add, simp rw exact refine rwa rw simp split_ifs rwa rw exact


obtain refine rw specialize split_ifs rw rw


classical cases obtain rw obtain obtain replace rw have intro rw split_ifs rfl rw simp replace rw replace fixed_of_fixed1_aux3 simp obtain rwa algebraMap_apply rwa algebraMap_apply


obtain have have obtain obtain replace rwa replace replace rw rw simp simp exact fixed_of_fixed1


let have suffices let exact congr_arg rintro obtain cases algebraize haveI haveI obtain have rw have refine rw rw obtain simpa exact


let have obtain obtain refine intro obtain obtain apply dsimp refine rw intro obtain obtain apply dsimp refine rw


Ideal.Quotient.normal

cases cases have constructor intro obtain cases obtain have rw have minpoly.dvd refine rw exact exact


let let map x have obtain obtain simpa congr map_id map_comp have obtain exact obtain let have change simp rw simp refine ext obtain lift change rw simp congr ext simp rfl


have obtain σ obtain refine ext obtain exact


ext rw split_ifs calc h.basis.repr rw rw rintro simp


Submodule.IsPrimary.inf

obtain obtain refine simp_rw and_or_right] exact


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


IsTensorProduct.inductionOn

rw generalize change induction zero tmul rw apply add rw apply


ext refine rw assumption intro rw intro rw


obtain let change let refine map_smul dsimp dsimp simp_rw let exact rw refine ext simp apply ext change rw rfl


IsBaseChange.ofEquiv

apply intro have ext change dsimp rw cases refine ext simp, rintro ext simp


IsBaseChange.comp

apply intro letI haveI rw rfl⟩ have refine change rw rfl refine ext simp rintro refine rw ext rfl


apply intro letI haveI haveI let let refine apply simp intro apply apply_fun rw rw


ext refine simp exact intro rw congr exact intro rw


use rintro refine rw intro rcases exact exact


constructor intro rw push_neg exact refine contrapose rw push_neg exact


intro unfold have refine refine haveI exact refine rw rcases exact exact


unfold refine rw refine have rcases exact exact simp_rw intro haveI exact


have constructor intro replace rw simpa intro replace rw simpa


have constructor intro have rw simpa intro have rw simpa


refine haveI refine suffices rw replace rwa exact refine have simpa


constructor refine have rw have rw push_neg rcases convert by_cases rw rwa have refine rwa have exact refine rwa have rwa refine rw exact


rw refine obtain have refine have intro have rw intro by_cases exact exact rw rcases exact exact refine rw refine exact isMaximal_of_isMaximal_disjoint exact


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


by_cases exact rw let have have obtain let have let let let let refine exact


rw intro let let have have intro apply intro replace change rw rwa have let have have suffices replace rw comap_map_of_surjective refine exact apply exact


refine intro exact isJacobsonRing_of_surjective


let have obtain have let let let rw have hm map_injective rwa have suffices rw exact let have suffices rw refine have exact rw let refine apply rwa


refine let obtain let let let have have let refine refine exact let quotientMap_injective suffices rw refine exact have exact rw


let have let have have rw refine refine simpa refine rw refine have apply any_goals obtain rwa


have let have rw refine rw norm_num exact


let have have let let let have ext simp rw apply apply apply apply suffices rw rw apply rfl apply exact


cases have let have change have have let have rw refine rw norm_num exact rw convert refine exact


refine rw swap intro rw intro refine rw swap intro rw intro simp dsimp rw simp


apply rw rintro exact rintro have rw clear refine rw intro have simp_rw rw refine apply exact intro rw exact


apply rw rintro exact change rw conv_rhs exact


rw rintro obtain have rw suffices refine rintro refine apply exact exact rintro rintro exact


apply intro have rw refine rintro rw intro intro


rw apply intro have have constructor intro exact e₂.symm intro exact


classical use apply rw rintro exact rw rintro let change have apply intro simp refine simp exact simpa


rw simp_rw simp simp_rw congr rw apply simp_rw exact


rw congr ext simp simp rw simp simp simp simp


apply rintro induction zero tmul obtain simp induction simp simp simp add convert_to rw congr convert ext rw rintro use use use


classical ext constructor rintro obtain simp map_D, intro obtain obtain replace rw obtain simp rw simp apply intro simp simp have simpa obtain use simp simp_rw simp rw have convert simp_rw simp


Algebra.Generators.Cotangent.exact

apply rw ext obtain simp convert trans congr refine change simp simp intro obtain replace simpa rw obtain rw rw let have have simpa rw refine rw rintro simp toExtension_Ring, refine simp rw rw rfl


classical apply intro apply ext simp pderiv_X, obtain simp reduceCtorEq]


classical apply intro apply ext simp obtain simp


induction monomial induction monomial s simp algebraMap_apply, rw simp add add


letI have induction add simp rw mul_X simp aeval_X, rw rfl


letI have induction simp add mul_X simp algebraMap_apply, obtain simp simp add_left_inj, rfl


simp apply apply intro simp toKaehler_cotangentSpaceBasis, rw conv_rhs simp simp exact


let have simp congr exact let rw rw rfl exact rw apply simp ext swap change rw


letI obtain obtain change replace simpa simp refine rw


induction zero smul add tmul induction simp simp simp


refine apply intro obtain induction simp simp derivationTensorProduct_algebraMap] rw rfl simp


KaehlerDifferential.isBaseChange

convert refine simp tensorKaehlerEquivBase_tmul,


KaehlerDifferential.tensorKaehlerEquiv

have let let e₁.restrictScalars refine intro obtain dsimp induction zero add tmul induction zero add tmul obtain induction zero add tmul z suffices b simpa simp ring_nf


have obtain induction zero add tmul trans simp simp


apply simp tensorKaehlerEquiv_tmul_D] rw


apply simp tensorKaehlerEquiv_tmul_D] rw simp


refine exact intro rw refine have exact have have exact suffices rw exact refine obtain apply simp exact have le_trans have exact


let rw apply intro by_contra push have lt_of_le_of_ne have simp use simpa exact simpa


by_cases rw simp have rwa have have rw intro obtain let have lt_of_le_of_ne refine simp


refine gcongr exact ringKrullDim_le_of_surjective


induction of_equiv convert rw exact h_empty h_option simp grw exact


nontriviality cases rw push_cast exact simp suffices rw intro let have refine refine simp trans norm_cast simp exact


refine rw obtain have have have refine rw exact have simpa


rw apply exact rw ringKrullDim_eq_of_ringEquiv infer_instance


let suffices rw let let have refine rw exact have have rwa


have let set have rw exact let have refine rwa have have have have have rw exact have rw apply


refine nontriviality refine rw gcongr exact exact


induction of_equiv convert exact rw h_empty h_option simp rw


nontriviality refine wlog obtain have exact this obtain exist_ltSeries_mem_one_of_mem_last by_cases have rw exact let toFun intro have exact simpa q.monotone step grw


nontriviality nontriviality have have simp apply simp intro have simp have simp let p.map obtain let have exact


induction nil rw simpa cons ih have simp


have rw supportDim_self_eq_ringKrullDim] exact


tfae_have intro change rw simp tfae_have refine obtain exact obtain exact tfae_have tfae_have rintro obtain obtain exact tfae_finish


induction by_cases exact obtain refine rw simp


classical refine ext grind simp intro refine simp simp intro simp intro simp obtain obtain simp contrapose suffices rw rw


InfIrred.isPrimary

rw refine let add_mem zero_mem smul_mem have intro simpa obtain rcases specialize refine simp obtain have rw rwa rw refine replace rw rw simpa


constructor contrapose simp intro rw use simpa rintro simp


ext rw by_cases rw rw contrapose exact contrapose simp lia


cases rw rw simp toPowerSeries_symm_apply_coeff,


intro by_cases exact set by_cases obtain obtain obtain rw apply rw gcongr obtain obtain obtain rw apply rw neg_neg] gcongr


refine let by_cases obtain rw exp_neg, by_cases apply rwa obtain rw apply intro rw apply lia simp obtain rw rw exp_neg, by_cases apply rw lia obtain rw apply intro rw apply lia simp


rw refine on_goal simp on_goal on_goal all_goals apply simp reduceCtorEq] intro simp lia


let let obtain mem_prod_iff.mp obtain obtain by_cases refine rw exact refine rw exact f.2.isWF.not_lt_min lt_trans exact use apply intro have refine simpa


let have intro simpa let let have simp intro simp by_cases exacts suffices exact simp constructor have rw convert ext simp rw intro apply simp


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


by_cases use simpa rw obtain use have apply simpa rw rw apply rw gcongr exact rw exact


set by_cases set obtain use have obtain rw have rw inv_eq_one_div simp rw apply rwa simp not_false_iff] obtain obtain use rw adicValued_apply, exact


rw ext simp intro rw obtain obtain obtain use apply apply simpa


rw ext simp constructor rintro obtain use simp refine apply simp rw assumption rintro obtain let refine refine simp use refine apply rw assumption


have by_cases rw intro rw obtain use constructor rw use rw refine rwa rw use simp rintro simp modulo


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


refine rw rw let change exact obtain rw simp


by_cases by_cases obtain obtain let let have rw let rw simp_rw have rw rw have rw rw


cases cases simp nontriviality rw intro obtain have refine le_trans rw exact


cases cases simp nontriviality rw refine simp


let nontriviality nontriviality by_cases rw congr simp rw cases let rw


simp_rw let let suffices change simp_rw ext simp exact


nontriviality refine have lift_rank_range_of_injective rw rw change exact


nontriviality rw obtain rw let replace have haveI rw exact


nontriviality by_cases rw rw exact by_cases rw rw exact haveI haveI haveI have exact of_finrank_sup_of_free


rw intro obtain obtain have let have fg_adjoin_of_finite replace have replace have rfl rw exact obtain obtain rw exact


classical cases set by_contra letI set have let have have have rw card_D] let apply_fun rw suffices have rw refine exact convert clear_value simp by_contra obtain refine obtain obtain rw rw apply rintro simp set rw card_units, have by_contra refine exact letI letI let have have haveI rw apply have simp rw refine refine rw obtain refine rintro exact


classical cases induction apply intro suffices rw simpa let rw trivial rw convert


delta apply intros constructor intro intro obtain exact


RingHom.OfLocalizationSpan.mk

introv algebraize let refine have algebraMap apply ext simp rw exact


have letI have have have apply ext simp rw exact


introv apply_fun rw apply rintro rw apply exact


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


simp apply intro rw rw have ext simp exact


apply injective_of_isLocalized_maximal intro convert_to rw apply exact


apply surjective_of_isLocalized_maximal intro convert_to rw apply exact


algebraize letI have have letI have apply injective_of_isLocalized_span simpa


algebraize letI have have letI have apply surjective_of_isLocalized_span simpa


IsIntegrallyClosed.iInf

refine intro have algebraize have rcases rwa


by_cases exact refine rintro exact rw convert rw


change refine rw have convert ext constructor intro obtain obtain use apply dsimp conv_rhs conv_lhs rw apply apply exact ext simp rintro obtain simp refine apply simp apply apply exact ext simp


have obtain let let have rw convert have letI obtain exact


apply intro refine map_smul intro obtain apply dsimp simp


introv constructor rintro simpa obtain dsimp let simp rw obtain apply_fun simp rw replace rw exact


introv constructor intro apply intro specialize exact


classical have choose choose use refine rw intro lift rw exact


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


let suffices refine obtain rw obtain simp_rw exact


let suffices by_contra have let obtain rw have simp_rw exact


IsLocalRing.maximalIdeal.isMaximal

rw constructor intro apply exact intro rw rcases simpa