rw revert simp_rw rw mul_inv_cancel_right₀, exact


AffineMap.restrict

refine exact refine rw exact intro simp apply


refine rw exact rw rcases have have rw simp exact


ext refine subst simp_rw rw have rw exact subst rw change have rw exact


ext simp sum_singleton, constructor rintro simp rintro exact


intro have obtain rw set have have have simp simp norm_cast


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


refine rw have simp_rw h₁, ext specialize have constructor simp simpa


rw vadd_vsub_vadd_comm have apply simp simp_rw rw card_univ, have rw have norm_cast0 congr rw


symm rw congr simp_rw symm rw have nth_rw rw


have unfold apply rw have rw have rw congr rw rw exact have rw apply exact exact


rw set have let let have intro have grind have set have have unfold grind have simp_rw set have grind have have convert grind have simp have have rw tauto choose have have simp_rw exact


have have apply exact rw simp_rw suffices rw simpa ext suffices simpa congrm simp


by_cases simp refine have rwa sub_nonneg] rwa


obtain letI suffices rw exact rw rw apply intro obtain rw


refine by_cases exact have rw g.map_eq_zero_of_not_injective


refine dsimp intro obtain rcases substs simpa simpa suffices exact suffices exact


apply rw congr ext1 induction h set calc conv_lhs simp simp_rw sign simp


simp refine rw have have simp smul_comm congr rw simp


by_cases rw rw apply apply apply apply apply


constructor rintro refine simpa rintro refine invFun left_inv right_inv map_add map_smul simp simp rw refine simp exact simp exact


by_contra simp obtain have simp let have have have have apply rw intro simp_rw change ext simpa congr have ind b.repr.injective ext obtain simp_rw classical exact exact


let map_add map_smul have refine change rw calc b.repr rw rfl


Module.Basis.mapCoeffs

letI haveI smul_assoc change rw exact ofRepr


nontriviality subst apply intro ext simp intro ext simp intro ext simp apply exact


apply rw rintro have revert generalize intro induction mem zero add smul replace simp rw


rintro obtain wlog let rw apply replace simp simp have obtain simp hslzero, replace simp simp map_sum, exact


classical apply intro trans simp simp split_ifs


rw intro contrapose refine rw rintro simp convert


Submodule.inductionOnRankAux

haveI have apply intro exfalso rw simpa induction zero suffices apply succ apply intro apply intro refine convert ext refine intro refine rintro exact


constructor intro constructor intro apply intros exact intro rw constructor intro rw simp_rw intro rw sum, simp_rw smul_mul_assoc, rw intro rw sum, simp_rw smul_mul_assoc,


constructor rw exact intro by_contra apply change simp_rw rcases rcases rcases simp rwa


refine obtain rcases refine by_contra specialize rw exact rcases exact


let let have have have rwa let have let haveI refine rw have change simp_rw dsimp rw exact


set set have simp simp set have apply apply exact simp simp have rintro simp use simp field set set have refine rw apply intro by_cases simp suffices rw apply apply simp


lift have set obtain simp rcases use simp_all set have simp simp have refine simp set have apply apply exact simp simp have rintro simp use simp set refine apply_fun simp apply intro rw simp rcases simp suffices apply_fun simp


cases apply intro rw apply rintro obtain simp apply exact rw rintro obtain simp apply rintro rw simp_rw rw exact


constructor ext obtain subst obtain subst rw rw


classical rw intro have have apply intro rw simp_rw exact


ext rcases constructor simp intro rw change rw rfl simp_rw refine ext change rw exact


ext simp refine ext obtain simpa ext simpa


rintro simp exists_prop, refine ext exact


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


constructor ext obtain subst obtain subst convert subst


simp rcases refine ext simp simp replace have rw simpa have by_cases simp simpa replace obtain simpa let refine ext rw simp apply intro simp


have classical rw intro simp obtain simp split_ifs simp have rw simpa apply contrapose refine simp contrapose apply simpa have let specialize simp obtain simp smul_eq_mul, have simp rw have suffices rw rw simp simpa have suffices rw rw simp simpa rw rw symm apply contrapose simp replace by_cases rw have simp rw let have obtain rw simp refine simpa apply simpa


rcases use ext apply let let rcases have have simp_all exact


by_cases rw let use apply intro nth_rewrite simp obtain refine


nontriviality have let let rw congr ext simp


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


nontriviality unfold set rw set set set let let let let let let calc


CliffordAlgebra.induction

let mul_mem add_mem algebraMap_mem let have ext simpa using rw exact


rw ext induction algebraMap add have exact ι_mul_ι_mul ih have exact


obtain ext change rw ext change refine rintro change rw simp rintro rw rintro rw


obtain cases refine dsimp induction algebraMap generalize_proofs simpa add rw simp ι_mul_ι_mul


CliffordAlgebra.toEven

refine refine exact rw exact ext1 rw erw dsimp rw


CliffordAlgebra.ofEven

let haveI haveI haveI intro rw refine intro rw intro rw mul_assoc,


induction algebraMap ι simp neg_e0_mul_v, mul add


intro have rw induction mem induction algebraMap add mul_mem obtain exact zero add


refine intro induction algebraMap add mul_ι


dsimp rw refine congr induction algebraMap add ι_mul


simp_rw apply simp_rw rintro refine simp exact


obtain dsimp induction mem obtain dsimp induction algebraMap add rw rfl mem_mul obtain rw refine dsimp rw rfl zero rw apply apply add


induction zero add mem obtain dsimp induction algebraMap add mem_mul obtain rw mul_assoc, clear congr induction zero add mem clear obtain dsimp induction algebraMap add mem_mul obtain rw ih₂,


unfold rw induction mem obtain letI letI letI simp_rw inv_mem obtain letI letI letI simp_rw one mul simp_rw suffices obtain obtain simp_rw


unfold induction mem obtain letI letI letI simp_rw inv_mem obtain letI letI letI letI letI simp_rw one mul simp_rw suffices simpa obtain obtain simp_rw


suffices apply exact have refine simp intro erw rintro exact


rw refine rcases simp simp simp refine rw have rw simp apply_fun simp simp


letI apply apply rw simp rw simp rw rw simp rw


let have refine ext simp congr_tmul, rTensorHomToHomRTensor_apply,


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


classical ext simp refine simp choose use ext simp by_cases rw rw


apply apply intro simp exact rintro exact


apply refine rw simp rintro refine refine by_cases simp simp


classical rw refine rintro refine ext simp


classical rw constructor use rw symm apply intro contrapose intro rw ext rw suffices exact intro rw rw rfl refine rintro refine rw exact exact simp rw exact intro rw rw rfl


rw suffices letI rw exact rw intro ext rw refine rwa


classical simp_rw constructor intro apply rw rw exact intro obtain contrapose use refine beta_reduce split_ifs exact simpa specialize simp grind


rw constructor intro simpa intro specialize simp_all


iSupIndep.linearIndependent

classical rw intro let have apply rwa ext apply have simp simpa


nontriviality by_cases have rcases exact simp classical have simp


classical refine intro have rw exact exact


classical by_cases rcases rw rw rw have contrapose rcases exact simp


have let suffices obtain refine rw simp_all


classical let let simp_rw have ext unfold simp_rw split_ifs rw simp rw


constructor rintro set rw convert ext simp intro rw set have ext rw rw exact


apply intro rcases simp rw congr rw exact


let let let let let let let let suffices rw ext cases inl cases inl simp apply inr inr cases inl suffices rw exact inr simp rw simp


simp rw apply rintro apply swap apply refine apply convert exact


Module.Basis.sumQuot

let have ext apply apply apply exact convert unfold rw show bW.span_eq, congr


simp rw revert rw apply intro induction inl inr


have conv rhs rw congr apply let refine rw rw range_subtype] rintro have simp grind


have refine obtain exact by_contra obtain let have refine rwa letI obtain have contrapose haveI rw apply contrapose exact obtain have rw set set let have have rw exact obtain refine clear_value simp_rw rw refine replace rw have simp_rw erw


obtain obtain have rw have rw haveI rw eq_comm, exact


obtain rw mk_arrow] apply erw infer_instance


nontriviality constructor contrapose rintro rw have linearIndependent_iff.mpr simpa intro rw apply intro rw rintro obtain apply simpa


rcases obtain have cases refine obtain have cases exact


set have intro rw exact choose have exact


obtain card_pos.1 let classical let have rw exact obtain let refine rw simp_rw smul_sub] refine rw simp_rw exact obtain have exact


let set suffices use simp intro rw simpa ext have rw simp rw


haveI constructor intro obtain let have convert ext simp rw rcases exact rintro exact


simp constructor rintro exact rintro exact


obtain constructor intro rw rcases use have intro simp use have intro have rwa rintro have ext simp rw refine simp


haveI refine obtain refine simp_rw haveI exact by_contra rw obtain haveI haveI exact


simp_rw refine obtain exact obtain exact


haveI constructor rw rintro exact rintro obtain simpa b.linearIndependent.map


simp span_singleton_le_iff_mem] constructor rintro choose exact rintro choose exact


haveI obtain haveI obtain exact have rwa lift_umax]


nontriviality obtain by_cases refine rw obtain obtain exact haveI haveI exact


refine rintro obtain refine have rwa by_contra rw haveI haveI exact


rcases have refine rcases refine replace intro convert replace exact rintro have convert rw exact


cases simp apply exacts hs.of_isLocalizedModule_of_isRegular


cases have have apply have exact have exact


have have cases have have let let replace let have let let isLocalizedModule_iff_isLocalization.mp on_goal have rw lift_rank_eq_of_le_nonZeroDivisors lift_lift]


classical rw push_neg obtain refine suffices suffices refine simpa this intro induction zero succ rw by_cases simp cases simp rw have exact


obtain choose have have rw rintro apply rw exact refine rw add_comm, exact apply rwa


obtain have refine rw simpa obtain exact


have intro rw exact rw push_neg simp_rw exact


refine disjoint_iff.mpr rw rw have rw lia


obtain obtain rwa obtain refine have rwa


classical haveI cases haveI cases rw simp apply exact have rcases haveI have exact


haveI cases rw convert simp let let have intro rcases have span_le.2 rw replace rw subst rcases exact refine suffices refine exact simpa


fapply apply exact intro apply_fun simp exact


classical by_contra rw let obtain let have have apply rintro simp apply exact


haveI rw apply trans swap apply exact rw convert simp⟩ exact apply rintro apply


obtain have have rw intro apply simp exact exact le_antisymm


rw push_neg simp_rw refine exact le.trans rw rw exact


constructor intro rcases rcases refine exact rintro exact


induction zero add tmul simp congr ext simp


induction zero add single induction zero add single classical simp_rw split_ifs


TensorProduct.directSum

refine exact toModule flip toModule flip exact ext simp curry_apply, ext simp


IsBaseChange.toDualBaseChange

apply let set have suffices ibc.toDualBaseChangeAux from ext simp induction zero tmul simp conv_lhs simp smul add


intro induction simp mem_dualAnnihilator, grind


refine have cases exact nontriviality have let exact hn


rw by_contra suffices have lift_rank_eq_of_equiv_equiv bijective_id rw exact have have convert rw exact


by_contra obtain let have rw exact obtain exact


by_contra rcases let have refine rw exact simp


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


ext rw constructor rintro have simpa intro exists


have have convert calc rw rwa apply exact


let have have rw rintro obtain have simp have ext obtain have rwa have replace obtain simp


constructor rw apply intro rw intro simpa


constructor rw apply rintro simp rw exact


refine let have rw intro rw rintro rw obtain obtain obtain use rfl


replace let refine replace let have simp


apply rintro apply rintro simp homTensorHomMap_apply, rw simpa all_goals


apply rintro simp dualDistrib_apply, rw simp all_goals


rw constructor rintro simp exact intro exact


ext simp constructor intro exact rintro have rw exact


Module.End.HasUnifEigenvalue.lt

apply intro rw rw intro rw rcases rwa rw exact


intro simp rcases replace use rw map_zero]


rw simp_rw rintro nontriviality rw set by_contra replace let let have apply ext apply apply apply apply have rw sub_eq_zero] contradiction


classical suffices simp_rw exact intro induction empty insert intro obtain specialize rw rintro simp suffices rw exact obtain let simp_rw peel simp have refine exact rw suffices exact simp_rw refine rintro refine exact rwa


ext suffices simp_rw mem_genEigenspace_nat] intro simp induction zero rw apply succ erw


intro simp obtain use have exact replace rw constructor simpa refine suffices rw obtain rw rw


by_contra let have refine apply simp exact


by_contra let have le_inf_iff.mpr refine apply simp exact


have hasEigenvalue_of_hasEigenvector constructor contrapose intro have rw rintro simp apply apply rw exact have have rw exact rintro exact


refine obtain replace have simp rw simpa have rcases simp rw simp


have set have refine simpa rw conv_rhs enter ext rw


replace intro simp exact classical suffices simpa intro induction empty insert intro obtain specialize rw rintro simp suffices rw exact obtain suffices intro let obtain have rw exact refine refine simp exact rw suffices s.sup from simp_rw refine rintro refine simp exact


generalize induction ind obtain forall_or_exists_not choose replace simp_rw exact replace simp_rw have replace apply intro exact exact rfl replace suffices rw intro rw exact replace have simp_rw simpa


refine classical obtain obtain suffices exact intro by_cases simp have simp_rw choose let have let have have suffices rw if_pos rintro split_ifs rw have rw simp_rw suffices simpa have rw have suffices intro rw exact have have apply have have apply obtain exact exact rw have apply apply intro rw apply have apply intro rw apply have have rw exact specialize obtain rwa


tfae_have tfae_have h, use suffices simpa tfae_have h obtain use ext rw obtain rw exact tfae_have tfae_finish


set have let have rw exact have simp intro use rw have simp intro obtain use rw let let let let let let let have apply simp rw natTrailingDegree_mul have apply apply intro apply suffices suffices simp use rw rwa rw apply simp rintro use apply rw refine generalize_proofs clear induction


refine letI haveI have rw have exact rintro rw


induction zero succ rw by_cases rw replace simp rw refine rw


refine rw refine obtain refine rw congr obtain rw


letI haveI letI haveI unfold conv_lhs rw rfl


obtain dsimp induction algebraMap add mem_mul obtain simp_rw exact


rw intro induction zero add homogeneous let apply rw refine obtain exact


ExteriorAlgebra.liftAlternating

suffices refine refine exact refine refine all_goals ext simp intro ext simp


rw induction zero succ ih rw congr exact


ext rw induction algebraMap rw add ι_mul rw simp_rw


ext dsimp induction algebraMap add ι_mul simp_rw


apply rw rintro apply simp rw rintro obtain refine rw apply grind rw apply ext obtain rw


by_cases suffices exact suffices obtain rw refine rw use norm_cast simp have use apply use rw congr ext simp rfl


apply rw intro rw exact rw rintro rw obtain exact


have have apply apply rw rw map_comp_ιMulti_family,


simp rw congr ext dsimp by_cases subst simp rw


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


set have simpa set letI have rw h]) rw have rw rw


classical induction empty insert ih replace ih rw simp_rw exact replace simpa


constructor rintro exact intro rw exact rfl⟩


have rw rw apply replace le_antisymm rw convert rw rfl


classical by_contra simp_rw have intro induction zero succ ih have refine rw apply have apply calc n.succ have exact


replace let have obtain refine ext have simp refine rw replace replace rwa


ext constructor intro rw rcases rw rw exact apply intro rcases rw use simp


apply intro rw apply intro exact refine have intro haveI by_cases exact simp rw refine simp


classical simp induction zero add single


refine rcases have refine rw exact rintro exact


ext simp refine rintro exact rintro exact


intro let obtain simp_all set clear_value induction h intro rw simp_rw congr by_contra apply contrapose simp simp_rw


ext constructor rintro simp intro choose refine constructor


obtain dsimp simp nth_rw rw simp congr aesop


refine rw refine classical by_cases by_cases exact exact exact


refine rintro induction single rw exact zero add rw exact rw intro exact


refine haveI suffices rwa rw rintro induction zero single_add refine by_cases simp filter_single_of_pos] obtain exact simp


classical cases simp refine le_antisymm le_trans intro refine rcases exact rw refine exact


rw rintro rw simp haveI by_cases have rw rfl rw simpa intro simp simp simp by_contra exact


classical have linearCombination rw exact


classical refine obtain have simp rw rw ext simp ite_eq_right_iff] intro exact exact


simp refine by_cases exact let let have exact


Module.Free.ChooseBasisIndex.fintype

refine cases have rw infer_instance exact


let have let let let have let let let suffices calc have intro rw exact calc congr rw by_cases rw rw simp_rw


Submodule.quotientEquivPiSpan

haveI let let let have have intro simp_rw have intro simp constructor rintro exact rintro choose exact let have ext simp forall_true_left, constructor rintro exact rintro refine exact refine classical


classical rcases dsimp set let have intro simp erw simp ext simp have set let have convert rw exact rw have ext simp true_implies, refine rcases intro simp split_ifs convert calc refine rintro have rw simp convert convert rw specialize rw simp refine ext simp rw by_cases calc convert simp rintro have rw simp simp simp rw conv_rhs simp congr exact simp convert specialize rw simp rw convert simp simp rw congr convert exact convert rw let have rw exact let have ext simp have simp rcases refine rw exact rw congr rw generalize_proofs rw rfl


rw rcases simp have intro apply specialize simpa intro simpa


obtain have rw rcases refine subst exact have simpa


ModN.basis

set set set set let let have rintro ext simp let refine rw nG.mkQ_surjective.forall] intro simp rw replace simp rw choose refine simpa suffices exact ext simp


have let classical rw let refine dsimp simp_rw refine simp_rw change rw grind


let let have have refine rw obtain obtain mem_span_insert.mp obtain exact let have rw refine change rw refine rw apply rw exact exact


have obtain set_has_maximal_iff_noetherian.mpr obtain exact let have let have generator_mem by_cases have contradiction obtain have generator_maximal_submoduleImage_dvd choose cases let have have simp rfl) have refine rw refine rw rfl refine have mul_left_cancel₀ a have let let have have intro simp obtain exact have refine have intro obtain rw have simpa congr_arg have intro refine rw refine refine intro refine rwa intro obtain refine refine rw simp intro refine refine intro refine rw rw rfl intro refine intro rw refine simp exact rw simp


haveI cases induction ih let by_cases subst exact obtain obtain obtain exact


Module.basisOfFiniteTypeTorsionFree

classical have let obtain this.choose_spec let span let let have intro by_cases use rw exact simpa choose let have rw simpa let have let have suffices rw rintro apply intro calc rw obtain exact


cases induction ih obtain by_cases subst exact obtain obtain obtain obtain obtain exact


by_cases nontriviality simpa simp_rw obtain obtain obtain rw exact set have have simp congr have obtain exact have have apply obtain simp_rw simpa exact


obtain have change rw have rw rcases use rw rfl use rw convert ext rw rfl


Submodule.goursat

let let let let let have simp simpa have simp simpa obtain use rw simp rw ext constructor intro simp snd_apply] exact simp rintro simp rwa convert ext simp_rw ker_mkQ]


set set have use obtain rw simp have obtain replace simpa refine simpa obtain refine exact rw simpa replace exact


have simp_rw exact rw convert refine rw exact


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


symm refine simp_rw intro have have have rw zero_add] rw convert rw simp_rw by_cases rw eval_interpolate_at_node mul_one, refine rcases rw have rw rw refine congr exact eval_interpolate_at_node


classical simp_rw mul_comm congr have calc derivative^ rw grind rw congrm refine grind exact grind exact


have apply exact simp rw exact rw intro rw replace obtain simp


rw let let let let have have have have ext simp rwa


nontriviality refine by_contra rw obtain refine have h.comp fin_cases rfl simp simp rfl convert ext fin_cases


intro let let have dsimp rw rw have rw have dsimp rw rcases use exact


let have apply convert change apply intro rcases convert rw


rw rintro simp_rw have refine exact rw exact


classical rw refine intro refine exact rintro rw intro have rw simpa exact rw rw have refine exact exact rcases exact rw exact


LinearIndepOn.union

nontriviality classical have have rw convert rw rw


letI letI apply intro induction empty insert intro have ext rw apply ext calc simp congrm rw rw simp simp have by_contra obtain contradiction have let have rw exact h.resolve_right have calc g rw simp rfl exact


classical exact linearIndependent_iff'ₛ.trans convert exact


classical simp_rw constructor rintro simp_rw exact rintro simpa hv


simp refine h refine iterate simp_rw rwa


constructor rintro specialize rw exact intro specialize p ext simp) have dsimp rw simpa


classical letI haveI rw refine specialize simpa refine simpa simpa specialize simp_rw exact rw conv_lhs conv_rhs convert congr simp simp simp simp intro by_cases apply simpa apply simpa


rw refine specialize by_cases exact exact specialize rw convert intro simp refine


rw refine simp rw simpa specialize h i.2 conv enter rw change rw simpa simpa


classical exact linearIndependent_iff'.trans convert exact


refine linearIndependent_iff''.2 rw refine rw


classical simp_rw constructor rintro rw exact rintro simpa


classical rw refine refine rwa simp exact replace simpa apply


classical exact linearIndepOn_iff'.trans simpa


apply constructor intro apply intro by_contra exact


by_cases refine rcases rcases exact refine rintro exact


refine rintro suffices have refine rintro simp


let let let have intro dsimp rw intro rcases rw haveI classical obtain f.support.coe_union simpa exact have obtain exists_maximal_of_chains_bounded exact


classical rw refine specialize simpa have rw obtain exact simp


simp intro specialize h abel) obtain constructor suffices calc rw suffices calc rw


rcases suffices rw push_neg by_cases simp by_cases refine simp module refine simp module refine suffices rwa convert ext


classical rw apply apply exact intro induction empty insert rw refine rw exact


nontriviality apply rintro by_cases subst refine rw have apply disjoint_def.1 rw simp rw exact exact rw apply


classical rcases use intro specialize set have have have refine intro rw exact obtain have contrapose refine simp rintro refine rintro exact use have rw rw refine exact


simp rintro refine have rintro simp_all match_scalars


classical rw linearIndependent_equiv simp rw simp


obtain refine refine exact exact exact refine subst exact


obtain choose let have let refine rw apply rintro simp simp


classical have s s have have have rwa have have eq_empty_of_subset_empty let have simp let have have have simp have have simpa have rw let simp have ext1 by_cases apply intro exact


LinearPMap.ext

rcases rcases obtain congr apply intro apply


choose set have intro dsimp rw apply simp simp apply use rintro rw apply simp rw intro rw apply simp


rcases subst simp have have rintro apply have rwa set have intro rcases exact use intro rcases set set rw intro simp rw intro refine exact


ext simp constructor rcases exact use simp


ext constructor rw rcases rw rw simp use rw rcases cases simp rw rcases use rw simp


constructor rw rcases use rw exact grind


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


intro rw obtain use simp convert refine simp


refine convert simp intro have convert exact exact


ext constructor rw rcases convert exact rw have simp exact refine rw exact


ext rw rw apply intro congr by_cases congr ext subst have rw simp_rw rw congr rw have apply rw rw apply simp apply intro exact


nth_rw rw have refine congr simp conv_lhs ext simp


ext simp obtain rw sdiff_singleton_eq_erase, rw refine obtain rw rw


rcases haveI rw replace let suffices rw apply calc


haveI obtain obtain let suffices simp_rw exact rw simp_rw


constructor intro refine simp rw intro refine simp rw


have rw exact refine simp rw mul_adjugate,


let let have intro ext simp have intro rw have intro rw have intro refine simp rw


rcases subsingleton cases exact rw let suffices rw map_pow have have mul_left_cancel₀ apply simp rw


cases let have have have have simpa obtain suffices replace replace simp_rw rw simpa classical


rw rw congr generalize cases simp fromBlocks_apply₁₁,


Matrix.BlockTriangular.det

suffices intro induction subst cases simp let rw have rw apply rw refine let have have rw refine let haveI simp erw rfl intro apply rw apply exact


let let have rw rw exact have ext simpa have haveI have ext exact rw


suffices intro induction subst intro haveI let let let obtain have simp simp haveI have have convert convert have simp


ext simp by_cases subst rw simp split_ifs rw split_ifs


have apply_fun simp apply_fun rw rw exact


let let have simp have simp have rw simp ring have rw simp ring dsimp rw


rw add_comm] simp rw apply intro apply rw apply rw apply apply rw intros apply


by_cases rw unfold rw simp assumption rw have rw simp_rw rw simp_rw simp rw exact rw apply rw lia


nontriviality by_cases rw apply have apply simp rw rw rwa rw rw rw apply rw lia


induction zero succ rw simp eval_add, rw simp intro cases zero succ simp rw intro rw exact rw exact


rw coeff_det_one_add_X_smul_one, convert rw


have ext by_cases fin_cases simp simp simpa rw suffices apply simpa


delta rw apply rintro rw have rw apply rintro rw coeff_X_mul_zero, exact rw exact


nontriviality let let let let have have have suffices apply rwa involutive_invert mul_comm] rw simp


obtain replace convert rw apply rw exact


nontriviality let have conv_lhs simp have have le_trans rw simpa


cases obtain rcases haveI dsimp apply repeat rw unfold rw apply refine rw exact exact exact


constructor intro have rwa intro ext simp_rw apply


have rw exact choose let have rw dsimp intro specialize rwa exact


classical cases exact obtain have rw obtain refine rw exact rw congr ext1 rw


cases apply apply rw refine rw contrapose


have simp simp of_apply, rename_X, apply rintro apply apply apply rintro by_cases simp simp


rw refine rintro obtain convert apply exact simp simp


obtain rw push_neg exact exact sum_involution have simp


induction empty insert have rw det_updateRow_eq_zero exact


obtain let have refine simp have unfold rw updateRow_comm update_eq_self] rw


induction empty rintro have congr ext rw insert intro have rw exact intro rw split_ifs rfl exact exact exact intro rw split_ifs simp rw


refine congr ext refine rw set have ext by_cases simp rw have have rw intro rw rw split_ifs rfl exact rwa intro rw split_ifs rw rw by_cases simp rw apply rwa


simp_rw rw simp_rw let have rw refine intro rw rintro simp intro ext simp have prodCongrLeft prodCongrLeft simp exact intro rw have have intro ext simp simp have refine intro simp intro simp apply ext simp simp intro rw simp intro rw obtain rw rw exact


classical simp_rw convert simp_rw refine intro simp intro dsimp intro have simp ext exact exact intro rw obtain use rw simp simp intro rw simp_rw rw congr rw rintro have rw simpa mt obtain rcases have exact rw rw


rw simp refine simp have rw refine rw calc simp


simp_rw have calc det rw congr rw refine rw congr rw ext rw


suffices rw intro induction zero succ h_ind rw neg_one_smul h_ind] congr ext simp_rw id_eq] split_ifs replace rw rwa obtain rw rw


constructor intro by_cases exact use rw simp_rw obtain rw apply simp apply simp intro apply


rw constructor intro specialize rwa intro specialize rwa


intro induction zero succ ih specialize hB obtain simp_rw intro choose exact have simp obtain simp by_cases obtain rw rw change refine apply exact exact simp rw use simpa rw apply


classical refine inhabit refine ext simp


nontriviality refine simp_rw refine constructor rintro simp exact


suffices obtain have have fin_cases simpa simpa simp_all simpa


induction step base have by_cases simp have have set have rw simp suffices simpa empty_val', simp_all simp neg_mul, vecMul, dotProduct_of_isEmpty, lt_neg, refine simp exact rw exact


have rcases exact suffices apply intro by_cases simp simp intro rw simpa


rcases simpa constructor intro refine simpa refine simpa


ext rcases simpa constructor intro obtain obtain have refine simp rintro exact


rw induction zero simp succ ih have card rw simp rw simp


rw have suffices grind have constructor rintro simp intro use ext fin_cases tauto


constructor exact rintro constructor refine rw simpa suffices rw have tauto rw simp hnsq]


rw constructor refine have have have ext fin_cases rintro simp


rw obtain refine rw rw induction base succ simp simp rw ring_nf suffices refine rw rw rw


rw constructor rintro have have simp exact apply refine rw simp_all refine rw simp_all rintro


cases exfalso exact obtain obtain have contrapose ext rw refine exact have rw exact simp_rw refine calc rw rw exact rw rw exact


contrapose suffices exact refine rw exact


simp_rw intro have let use intro obtain by_cases simp convert simp simp simp


ext classical constructor intro inhabit simpa intro rwa


ext classical constructor intro rw refine intro simpa


ext constructor intro refine simp rintro simpa


ext constructor intro exact rintro rw exact


intro simp rw replace rw intro specialize have use simpa


simp_rw congr refine refine rw congrm ext simp


letI by_contra have obtain obtain have have have obtain obtain exact


letI induction zero refine rcases exact simp_all simp succ rw constructor intro obtain simpa have have have have obtain exact rintro cases nil simp have let have exact


letI constructor intro obtain refine have have simpa intro constructor exact intro obtain obtain exact


Matrix.IsIrreducible.transpose

have refine intro letI obtain cases nil let letI use simp


constructor intro refine exact exact exact exact rintro convert


refine ext specialize simp_all ext contrapose use rw simp_all


refine rw exact change rw intro replace simpa


rcases simp rcases rw subsingleton have refine simp


obtain obtain obtain simp letI simp apply


by_cases swap cases subsingleton have refine rw exact rw by_cases cases subsingleton have refine rw exact rw apply rw


rw refine refine simp intro calc natDegree natDegree rcases rw rw dsimp compute_degree


rw refine simp intro convert rw convert simp rintro dsimp compute_degree


cases simp rw simp rcases simp rw have rw simp


classical induction empty insert rw by_cases simp_all exact


have rw constructor refine have rwa dotProduct_mulVec] refine rw apply rw apply rw apply


have refine let have rw aesop rw have simp_rw exact


cases let let refine rw congr apply rintro apply have have rw rw simp toLin_self,


classical set have have convert ext simp have suffices simpa simp_rw simp rw


dsimp refine dsimp trans finrank finrank rw simp


ext simp constructor intro replace rwa intro rw


classical let let let rw add_le_add_iff_left] apply rw


ext obtain rw obtain rw rw rw obtain rw rw


by_cases have cases cases letI simp_rw have have simp_rw


convert letI letI refine exact change fromBlocks fromBlocks simp zero_add,


suffices exact letI letI letI letI letI refine exact


rw intro have contrapose rw decide obtain exact


have ext simp_rw mul_inv_eq_iff_eq_mul, have simp_rw refine simp_rw exact let have let replace detp simp_rw rw simp_rw rw conv_rhs refine replace contrapose rw exact obtain replace rw split_ifs rw simp_rw refine rw simp


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


suffices intro simp_rw intro rw rw replace rw simp_rw obtain rw exact


suffices intro rw intro simp_rw intro rw rw rw replace rw obtain rw rw rw apply have rw exact


ext simp rw conv_lhs rw apply rintro rw apply rintro simp intros simp intros simp


ext simp sum_mul] rw conv_lhs rw apply rintro rw apply rintro simp intros simp intros simp


rw have intro constructor rw exact simp_rw rfl


have let let let let suffices dsimp simp simp convert rw rfl rw rfl rw conv_rhs rw


constructor intro obtain refine simp rw exact


rcases refine have simpa exact suffices simpa


unfold split_ifs subsingleton dsimp generalize_proofs generalize subst rw


induction zero succ simp_rw congrm rw pred simp_rw congrm


rw rw intro rw intros have contradiction


constructor rintro contrapose exact contrapose intro have simpa have refine rw exact exact


have rw refine refine exact ext refine rw letI obtain choose refine have rw exact ext refine calc algebraMap simp_rw rw


cases simp contrapose obtain wlog refine rw obtain simp_rw simp_rw refine rw exact obtain refine rw rw refine by_cases rw exact


cases ext rcases by_cases simp simp by_cases


suffices k intro induction of_succ have let rw have simp simp by_cases have cases simp simp simp listTransvecCol_mul_last_row_drop simp have rintro cases simp simp rw rcases simp rw simpa simpa self simp rw simpa


induction zero succ have let have simp rw simp


suffices k have rw have simpa intro induction zero succ have let have simp by_cases have cases simp simp have simp if_true, field have rintro cases tauto simp rcases simp rw simpa simpa


by_cases refine by_cases exact simp have rcases contrapose rintro exact contrapose rintro exact rcases let have rcases rw refine simp exact let have rcases refine simp rw exact


rcases let let rcases set refine suffices diagonal have rw rfl rw simp


rcases refine have simp reindexAlgEquiv_apply] rw simp simp simp


suffices intro induction zero refine ext rw exact succ have refine rw rw simp apply apply


rcases have suffices rw apply exact intro induction nil simp induction nil cons simp apply exact cons simp exact


let have apply grind intro exact intro exact exact


induction zero succ rcases simp rcases calc simp simp


induction zero succ z rw simp pred z rw neg_eq_zero, simp


revert refine intro have t.piecewise_insert have ext by_cases rw simp simp let have ext by_cases rw simp by_cases rw congr refine have ext by_cases rw simp by_cases rw


letI induction h by_cases obtain have rw by_cases have intro have have exact have intro congr have intro congr apply exact simp simp obtain obtain let let have intro by_cases rw simp simp have intro by_cases rw simp simp have ext by_cases rw have simp symm simp rw refine have rw simp simp have ext by_cases rw simp simp have ext by_cases rw simp simp have have refine have simp exact rw exact have have rw exact have haveI piFinset_disjoint_of_disjoint have apply intro by_cases apply refine by_cases have rwa simp apply refine by_cases have rwa simp exact rw simp rw


refine intro have ext by_cases rw simp simp rw simp


refine rw rw simp_rw congr congr rw exact exact cases rw push_neg rw apply grind


rw refine by_cases rw rw rw obtain rw rw rw


cases classical ext rcases unfold simp_rw


ext change classical cases rw simp_rw congr simp_rw exact


ext obtain simp rw rw obtain apply simp_rw


classical conv_lhs congr ext obtain rcases suffices simpa exact simp


induction zero haveI exact succ ih suffices cases exact cases exact


ext change obtain have have rw simp_rw congr simp_rw exact


induction h dsimp simp rw intro set have convert ext fin_cases rw simpa


induction h rw rwa sameRay_neg_smul_left_iff_of_ne ne_comm]


dsimp split_ifs left rfl right simp mul_one, ext simp


refine replace simp refine rintro simpa suffices simpa set have set obtain refine replace simp obtain simpa rw simpa


let rw refine replace have induction mem obtain simpa zero add smul rw ext simpa


rw refine obtain refine ext apply change simpa


classical have have obtain rw let have set have replace hv₃.restrict_scalars simp_rw exact rw exact suffices let let exact suffices apply rw simpa refine obtain rw let have have rw let have have replace simp exact have have rw exact


have exact restrictScalars_field_aux rw exact rw exact


refine simp rintro classical by_cases by_cases exact exact exact


LinearMap.iInfKerProjEquiv

refine intro simp intro have rw simp ext simp rfl ext1 apply ext have simp split_ifs rfl exact


refine induction mem zero add smul have suffices rw exact ext simp simp


have have rwa refine simp_rw refine convert


haveI haveI classical refine refine simp


ext simp constructor rintro rfl intro exact


constructor rw rintro simp exact rw rintro simp refine simp


apply rintro simp have simp use rwa rw rw simpa


constructor intro constructor rintro exact rintro exact rintro exact


constructor intro constructor rintro apply exact rintro apply exact rintro have apply simpa have apply simpa simpa


refine simp rintro simp have rcases refine rwa simp


obtain simp use toFun map_add map_smul intro simp refine rw apply rw ext simpa


obtain obtain have simp rw simp exact map_smul map_add invFun left_inv right_inv


constructor rw rintro rw simp rw intro rw refine rw


rw apply apply gcongr all_goals apply all_goals


rw ext simp h.map_id simp prodMap_apply,


rw constructor rintro exact rintro refine rwa


classical refine let have let intro exact


Projectivization.card

nontriviality cases inr have simp inl cases inr have push_neg have simp inl classical haveI haveI haveI have simp_rw rw


wlog have contrapose rwa have rw apply contrapose simpa simp have refine let have zify conv_rhs rw simp


rcases rfl induction h induction h rw cross_anticomm


refine rintro choose convert ext exact convert simp intro apply


refine rintro simp exact rw refine simpa exact


refine rintro contrapose choose convert ext simp convert simp exact


induction empty cons ih simp_rw if_false, polarBilin_apply_apply] congr rw congr rw


suffices intro induction zero succ obtain let rw exact obtain rw finrank_span_singleton let obtain ih let rintro rw rw have rw have exact intro refine obtain rw add_neg_cancel, refine rw intro refine simp exact rw exact exact exact


ext rw refine rw rw half_moduleEnd_apply_eq_half_smul] ring_nf intro rw module


ext rw simp_rw rw simp_rw simp_rw rfl intro rw simpa


QuadraticForm.isometryEquivSumSquares

let have intro exact convert ext1 rw refine have classical rw intro rw mul_zero, intro simp_rw erw split_ifs simp have simp rw suffices rw inv_mul_cancel₀


classical rw let let refine rw change have refine ext dsimp simp ext dsimp simp rw refine exact


refine set set replace classical simp_rw rw grind simp grind have suffices suffices simpa refine grind have have rw by_contra have grind replace replace grind


simp_rw constructor intro refine rw intro refine rw


simp_rw constructor intro constructor intro intro rintro exact


simp_rw constructor rintro obtain exact rintro refine rintro rw rwa


simp_rw intro classical have rw exact apply intro by_cases subst rw


simp_rw constructor intro classical convert rw rw rintro exact


simp_rw constructor rintro intro exact intro refine rw exact exact


let have have have by_cases simp simp convert ext1 classical suffices simpa exact


letI rw have convert associated_left_inverse


suffices have let have rw use rw exact rw rw rw exact


simp_rw rw rw rintro rw intros have contradiction


SameRay.trans

rcases rcases rcases exact rcases rcases refine rw


rcases rcases rcases rcases rcases refine positivity convert


by_cases by_cases simp_rw refine rcases exact exact refine rw simp exact exact refine rw simp rcases rw dsimp rcases refine linear_combination exfalso simp refine linear_combination exfalso simp rw exact exfalso simp refine rwa exfalso simp refine rwa


rcases use simp use simp have refine rw rw rw


refine have suffices have rw exact specialize simp simpa have simpa


have let have ext simp abel replace intro induction zero succ ih have rw simp_rw add_smul, suffices obtain replace simpa exact


set rw have have simp rw simp let have intro simp rw simp rw exact exact


induction zero succ ih have intro rw simp reflection_apply_self, abel


suffices rw exact contrapose apply rw intro rw n] exact


rintro congr suffices rw exact eq_of_mapsTo_reflection_of_mem intro simpa


classical obtain obtain have rw refine simp simp_rw use replace linearCombination rw simp_rw let have rw have simpa


obtain replace obtain simpa obtain have simpa suffices rcases left right norm_cast rw tauto


suffices obtain have rcases left right intro let replace suffices rw rw obtain replace have intro by_cases change simp replace simp_all refine by_contra replace contradiction


rw refine rcases exact exfalso exact contrapose


rcases simpa classical let have have rw simp intro rcases simpa simpa


classical simp_rw suffices rcases obtain exact obtain exact intro refine rintro exact intro refine exact


obtain refine by_contra replace exact refine by_contra replace exact


suffices intro obtain rw b.support.sum_subtype have simpa


obtain rw rcases refine by_contra replace by_cases exact simpa exact refine by_contra replace by_cases exact simpa exact


by_contra suffices obtain replace refine rw contrapose exact have algebraMap_injective simp_rw rw refine by_cases exact simp_all


replace refine letI replace rw lia induction zero succ hw obtain replace simp lia replace exact pred hw obtain replace rw simp lia replace exact


generalize induction zero succ obtain rw rcases obtain have have exact pred rw lia


apply intro refine simpa simp by_cases have rw simp replace replace simp


generalize induction ind obtain rw rcases have have suffices have lia have rw rw replace aesop simpa


refine letI have refine clear intro rw exact


have have let let change suffices let obtain have have rintro rw simpa exact


let rw rintro apply rcases simpa have rw simpa


let let letI have let change have suffices rw simp apply rintro suffices rw image_comp] convert aesop rw exact have let replace exact rw replace rw simp rw


letI have have have rw suffices replace rcases exact suffices replace exact refine obtain obtain replace replace replace replace rwa lia


letI letI let let obtain have have have refine simp exact simp let have obtain simp have obtain simp rw exact


let let obtain exists_dual_forall_apply_ne_zero letI exact


have injOn_dualMap_subtype_span_range_range rintro exact


RootPairing.ext

have ext refine conv_rhs simp simp suffices have ext apply simp apply exact exact exact exact exact


set set set set set set let have ext have simp obtain rw have simp rw abel suffices have have apply refine rw exact


RootPairing.IsRootSystem.ext

suffices have have exact clear rintro use apply apply exact change simp_rw exact exact exact


set set set set set set let have ext have simp apply apply simp ring rw exact


classical obtain replace rwa have rw aesop rw rwa


have have simp have have suffices by_contra replace rw refine refine simp


let have have refine contrapose exact have refine contrapose rw induction mem obtain replace rwa tauto zero add hy replace tauto smul have rw refine rw apply by_cases exact replace simp simp


classical intro obtain obtain let let suffices rw refine replace rw replace suffices simp refine simp_rw simp replace suffices simp refine simp_rw simp suffices rw apply rw exact


set let suffices obtain refine simpa apply rintro obtain refine rw simpa obtain contrapose apply aesop simpa


have suffices rw exact intro suffices simpa obtain apply exact exact intro replace simpa rw exact


replace set have have suffices intro have have have rwa exact have refine by_contra have replace replace simpa have rw contrapose replace exact have replace replace simpa have rw contrapose replace exact have have contrapose exact have apply rw simp have have contrapose exact have apply rw simp lia


set suffices simpa have simp obtain rw lia


letI by_cases have ext rw smul_neg, lia have simp chainBotCoeff_of_not_linearIndependent


letI by_cases have ext rw sub_neg_eq_add, have simp chainBotCoeff_of_not_linearIndependent


by_cases swap have simpa simp refine replace rw rw lia


have apply rw have replace have rw exact rw


suffices refine specialize simp pairingIn_reflectionPerm_self_right] lia intro have simp module have rw exact rw lia


have by_cases swap have set set have simp have rw have rw rw neg_neg] norm_cast


refine induction mem obtain simp zero add smul ext apply simp


rw induction zero add smul mem obtain exact


have simp_rw exact rw nth_rw rw simp rw simp sub_eq_zero] refine intro rw


have rw have rw rw mul_smul_comm, smul_eq_mul, ring


simp refine have have aesop specialize lia


suffices have have simp lia obtain push_neg refine have simp omega


suffices algebraMap_injective have have apply calc rw rw rw rw


suffices algebraMap_injective have have apply calc rw simp rw rw


suffices have simpa simp obtain have have have have have have apply


by_contra obtain have have have rw have ext have simp induction zero mem add smul simpa


have let let set set set obtain obtain replace replace rw rw have rw refine intro obtain change rw rwa have apply simpa simp rwa


have obtain have simpa obtain exact have simp norm_cast lia


have have aesop have have have aesop have have rcases lia


have have have by_cases suffices rcases replace exact replace rw exact have have have have simp_all simp_rw lia have have replace aesop simp rcases rw exact rw contradiction rw simp


obtain rw suffices have rintro rcases have rw simpa suffices replace rwa replace rwa


obtain suffices contrapose replace exact


obtain by_cases refine obtain refine by_contra have have have grind


have have by_cases refine have rwa obtain have set set have rcases refine have rcases simp aesop refine have rcases simp aesop


let let have have simp rw have have simp ring have have replace rw replace simp convert module ring_nf simp apply simp convert module module


have have refine have rw rw convert exact


have have suffices refine rw apply have have rw lia


rw refine rintro simp obtain rw simp simp


letI classical ext simp simp rw simp simp simp rw simp


refine obtain span_range_h_le_range_diagonal simp


induction mem hu obtain simpa rw exact exact exact zero add smul lie rw exact


rcases rw exact obtain have rintro rw exact suffices convert rw module have replace suffices replace rw exact have suffices apply simp simpa replace replace rw intro rw exact have have contrapose have aesop replace have apply simp convert simp ring replace omega


let replace rw convert simp module rw convert b.root_sub_root_mem_of_mem_of_mem simp module


have have rw intro obtain obtain rw exact let let have replace exact have replace exact have replace exact have replace rwa exact have replace replace exact have replace replace exact have replace replace exact have replace rwa exact replace convert replace rw ring replace convert replace rw ring replace convert replace rw ring replace convert rw ring have subst simp rcases lia


intro have letI have obtain have have have module have suffices algebraMap_injective replace simp simp have refine rw refine rw abel have have have suffices have apply simp simp have exact lia have have have rw have aesop apply rw simp replace lia have simp simp


intro letI have have have have rwa suffices contrapose rcases simpa refine rw simp rintro have suffices replace simpa obtain suffices refine rwa suffices have suffices algebraMap_injective simp have aesop obtain have have have have refine simpa i).resolve_right have suffices have simpa have aesop have lia


have letI suffices simpa have have have simpa have convert have simp have simp have grind rcases exact rw rcases simpa suffices have aux_2 have simpa aux_2 have have split have have split lia


classical ext simp simp rw aesop simp aesop simp mul_zero, rw rcases simp ite_self, refine simp ring


classical suffices replace simpa calc ω rw neg_mul, abel rw simp


classical have rw suffices have rw have rw simpa rcases rcases have have have chainBotCoeff_of_add have rw simp ring simp_rw replace have have chainBotCoeff_of_add simp simp_rw replace have have simp suffices exact


letI have have classical ext simp have simp rintro simp have simp rintro simp simp simp rcases have rintro refine rwa simp mul_ite, rw simp rcases have rintro refine replace simpa simp have simp rw simp rcases exact simp_all


classical letI have rintro exact have rintro replace exact simp


letI classical ext rw suffices have have simpa rcases rw by_cases obtain rw b.abs_cartanMatrix_apply, have have norm_cast aesop have rintro simp


letI classical ext aesop exact have simp rcases rw rcases rw lemma suffices have have rw simpa by_cases have rintro have rintro simp by_cases have rwa have rintro have rintro simp obtain b.root_sub_root_mem_of_mem_of_mem obtain by_cases grind have grind have grind rw if_pos have norm_cast


have have letI have rw induction zero succ rcases left rw have rintro replace simp one_smul] rw module rcases apply rw simp have exact by_cases obtain right refine ext simp rcases replace simp replace hml simp left ext simp replace simp


classical have have letI rw have ext simp have suffices exact simp rintro exact by_cases use replace ext simp have simp rw simp use rcases assumption exfalso replace have apply rintro apply convert module contrapose rw rw rw lia


obtain suffices suffices clear induction zero succ


classical letI suffices simp norm_cast suffices let exact


obtain suffices refine rintro simp simpa simpa


suffices obtain simpa replace obtain use rw exact clear intro have w set obtain replace have aesop simp obtain obtain replace exact let replace contrapose apply rintro simp contrapose suffices intro replace rw obtain simpa refine suffices obtain let replace rw obtain obtain simpa ext have simpa rcases simp suffices simpa rw exact simp_rw exact


suffices obtain obtain exact contrapose refine suffices have rw


letI have have obtain revert apply intro replace obtain exact intro let have replace rw exact exact intro have replace rw let change exact exact have refine suffices rw let let change exact clear suffices simp_rw aesop intro revert apply intro suffices exact intro have let change replace rw exact intro rw let have replace rw exact exact


refine replace simpa obtain obtain rw exact obtain simpa congr_fun rw rintro simp rintro exact


refine suffices let apply contrapose replace refine obtain suffices have contrapose suffices simpa rw suffices ext suffices by_contra have have have simp_rw assumption have contradiction


intro ext exact refine simp_rw exact refine simp_rw exact


intro ext dsimp rw have rw have haveI refine exact dsimp simp_all dsimp rw set have exact rw rw rw


refine have simp_all rw suffices apply exact


have refine rw intro by_contra obtain contrapose suffices exact replace specialize contrapose rw exact have contradiction


rw refine suffices let suffices apply simpa rintro induction mem one mul rcases suffices refine exact


refine simp rw have tauto let replace suffices exact


by_contra suffices refine obtain simp apply simp


have by_cases exact refine rwa apply simpa


obtain rcases replace simp replace simpa


rw induction mem obtain simpa zero add smul


rw intro induction mem obtain rw apply exact exact zero add smul


intro simp refine simp rw apply_self_mul_coroot_apply] ring


constructor rw exact intro have exact rw exact


rw refine specialize simp_all rcases tauto exact


refine rw contrapose rcases exact rw exact


have simpa rintro replace simpa rcases replace rw have lia rw replace rw lia


refine rw intro rw n] exact rw rw specialize simp rw exact


rw push_neg obtain replace rcases exact assumption have rcases exact assumption replace have replace rw exact


have refine contrapose have rw have suffices calc


have have refine have rw replace rw exact rw rw norm_num suffices rw simp


RootPairing.weylGroup.induction

let pred have suffices apply rintro exact exact intro rw exact


refine rintro simp use exact rintro induction one change simp mem obtain simp simpa inv_mem obtain simp simpa mul simpa


refine rintro simp use refine rintro induction one change simp mem obtain simp simpa inv_mem obtain simp simpa mul simpa


revert obtain induction mem one mul intro rw


have specialize replace exact ext obtain let have simp rintro apply rcases exact exact have let have exact simpa


rw isTorsionBySet_singleton_iff, let have have have have letI let exact


dsimp constructor rw rw rcases rw trivial exact


dsimp constructor rw rw rcases simp exfalso exact exact


classical rw intro have have apply intro rw simp_rw apply exact


constructor ext simp_rw exact intro let simp exact


rw refine obtain replace rw suffices rw exact


ext simp_rw constructor exact rintro rw exact


intro suffices have simp rw simp simp simpa


have ext simp have ext simp have simp_rw


constructor simpa have ext rw exact exact


refine let suffices apply simp_rw intro rw simp


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


rw rintro rw refine specialize simp_rw rw exact


intro refine obtain rw apply rintro rw suffices obtain exact exact


intro obtain rw ext rw specialize simp_rw rw exact intro replace rw intro replace rw


have rw exact rcases exact replace rcases rw exact replace suffices rw apply simpa simpa


have by_contra exact by_contra by_cases simpa have rw exact


refine have rw intro simp_rw specialize rw have simpa


constructor rintro rfl intro subst suffices ext exact intro induction mem zero add erw rw smul erw rw


convert constructor rintro rfl intro ext exact


suffices apply rw rw suffices refine simpa ext simpa


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


refine simp_rw intro refine exact exact exact refine rintro apply exact rw exact intro rw exact


refine refine iSup_induction exact exact rintro exact


refine suffices obtain exact suffices simpa intro rw exact


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


refine rcases obtain rcases simp have simp


induction mem induction mem zero add smul zero add smul


refine induction mem zero add smul clear induction mem obtain exact zero add refine rintro exact


rw simp_rw refine rintro exact rintro exact


let apply intro by_cases rw simp exact rw rintro rwa


classical refine refine rwa rw exact use simp rintro refine rw exact rw exact rintro exact


classical induction empty insert obtain obtain refine simp exact


refine obtain rw exact exact nth_rw exact exact


simp_rw constructor refine have exact refine have exact


constructor rintro rw exact intro refine


nontriviality let have rwa have infer_instance rw exact


rcases have simp let let rw let rw rw apply simp intro suffices simp rw simp apply intro simp ext simp


nontriviality by_cases convert apply rw simp have hV rw have suffices rw apply intro simp rw simp have rw set ext have simp simp rw simp


classical ext by_cases subst simp symm simp simp dsimp rw rintro contradiction


have classical have simp obtain by_contra simp_all have refine rw convert ext by_cases have use refine by_cases


IsSymmetricAlgebra.induction

rw generalize change induction algebraMap ι mul add


rw use refine rw rw apply_fun simp rw exact


TensorAlgebra.induction

let mul_mem add_mem algebraMap_mem let have rfl have ext simp rw exact


refine letI haveI have rw have exact rintro rw


rw refine clear ext simp refine congr rw


refine rw rfl intro rw simp_rw rw refine dsimp rw simp_rw congr


rw induction smul_tprod a rw congr rw refine simp add


let let let have let have suffices ext simp congr rw refine rw


SymmetricPower.smul

induction of cases perm apply convert let classical convert rw simp_rw rfl refl symm trans add


ext refine exact intro apply use intro exact


induction zero use rw tmul add obtain obtain apply


induction zero tmul add obtain obtain exact


induction zero tmul add obtain obtain use rw exact


simp_rw induction empty obtain refine exact refine exact exact obtain obtain refine exact exact exact


let suffices ext dsimp simp_rw simp_rw congr abel


dsimp dsimp rw simp_rw rw simp_rw rw rw dsimp simp_rw


intro induction zero tmul obtain exact add obtain obtain exact


simp rw apply apply intro suffices rw apply rw


rw apply intro simp rw refine intro simp rintro use rfl use simp rintro use simp rintro induction zero use simp tmul induction zero use simp tmul use simp with_unfolding_all add obtain obtain use simp add obtain obtain use simp rintro induction zero rw apply tmul simp suffices simp rw apply apply exact simp add rw apply


rw apply intro simp rw refine intro simp rintro use rfl use simp rintro use simp rintro induction zero use simp tmul induction zero use simp tmul use simp rfl add obtain obtain use simp add obtain obtain use simp rintro induction zero rw apply tmul simp suffices rw simp apply apply exact simp add rw apply


have rw simp rw simp rw rw rw apply simp rw rfl


Subalgebra.lTensorBot

refine rintro obtain replace obtain replace rw erw rw exact


refine rw span_eq_top_of_span_eq_top refine rw exact refine


set have have apply apply rw apply rintro use set have simp have have rTensor_exact have obtain obtain refine intro classical apply_fun apply_fun symm simp one_smul, rTensor_tmul, en] simp convert split rw rfl rintro simpa


have set have apply rw rfl have apply simp have unfold convert convert simp


apply rintro obtain rw apply simp have rw have rw unfold convert symm convert simp


classical cases apply rintro simp rw obtain simp rw simp


let have refine ext simp trace_eq_contract_apply, simp trace_eq_contract_apply,


classical by_cases obtain haveI haveI haveI haveI rw rw rintro exact hM


by_cases swap rw exact obtain classical rw apply simpa


set replace rw refine exact have have simp rw


interval_cases have simp let ext suffices let suffices rw rw intro have rwa


suffices refine rw exact rintro rw apply


simp constructor simp rintro apply apply rintro simp intro simp simp set rw by_cases use ext suffices rw simpa rw replace rw obtain use ext rw suffices suffices rw nth_rewrite rw exact


classical by_cases by_cases simp by_cases simp obtain have rw suffices rw ext rw simp mul_one, apply by_cases rw rw by_cases rw rcases simp obtain have rw suffices rw simp rw simp intro simp simp ext rw simp smul_eq_mul, rw simp split_ifs simp rw rw convert by_cases simp simp


LinearMap.transvection.det

rcases subsingleton let set let let have let let have have set set have let let have apply intro rw apply have rw ext rw simp apply rw rw


induction zero succ since wlog obtain obtain simp rw rw det_permute, rfl from set set have ext simp simp ring and rw det_succ_row_zero, rw simp show field_simp simp field_simp simp intro obtain rw refine simp ring


let have simp norm_cast rw apply_fun rw convert


constructor simp rintro exact simp refine rw


induction zero succ rw push_cast congr simp norm_cast simp rw simp


suffices change rw rfl have rw exacts obtain simp


ext by_cases rw rfl have simp exact subst rw rfl


n induction zero succ rw rw finCycle_apply,


PartialEquiv.ext

have ext exact have ext exact have have rw cases simp_all


intro let cases intro let have intro suffices simp assumption congr exact


ext by_cases obtain rw by_cases obtain rw exact rw exact rw exact


classical refine simp have have have have simp rw


intro wlog exact unfold have exact coprime_mul_succ


rintro replace classical refine apply_fun simpa apply_fun simp exact


simp_rw refine rintro obtain exacts rintro exact


rintro classical obtain rw obtain refine rw rw refine rw rw


Acc.cutExpand

induction refine classical simp rintro refine rw exact


Function.Surjective.nontrivial

rcases rcases rcases have refine rw exact


induction refl tail rcases rcases exact cases exact exact


refine induction single tail rcases exact


induction refl rcases have clear induction refl rcases cases refl single rcases exact rcases cases refl single


by_cases refine obtain exact simp infer_instance


Pi.opensMeasurableSpace

constructor have rw apply rintro refine rw exact


Prod.opensMeasurableSpace

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


refine rw apply rcases rw exact rcases rw exact


have rw exact tendsto_measure_biInter_gt have apply filter_upwards rw convert exact


letI apply intro have suffices rw intro exact have ext simp rw exact


classical rcases have set have set refine simp_rw split_ifs simp_rw exact exact exact


obtain exists_seq_strictAnti_tendsto choose have have filter_upwards intro rw exact exact


classical inhabit rcases exact let have have set dite have intro simp split_ifs refine exact exact have h_ae_eq.mono have measurable_of_tendsto_metrizable exact


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


rw refine refine obtain rw exact refine obtain rw exact


set refine letI rw refine rcases by_cases convert_to ext push constructor intro rcases rcases exact rintro exact refine refine exact rcases have convert_to ext simp refine have contrapose exact rcases exact refine exact


set refine letI rw refine rcases by_cases convert_to ext push constructor intro rcases rcases exact rintro exact refine refine exact replace convert_to symm simp intro rcases exact refine exact


convert ext constructor exacts erw exact


apply rw apply apply rintro borelize exact


refine ext_of_generate_finite rintro exact


rcases have hsc.biUnion simp refine rintro exact refine rcases rcases exact rintro exact rintro exact


refine rcases have simp rw measure_diff rw finiteness finiteness


classical rcases rcases convert rwa have have intro apply have ext by_cases simp simp rw exact have let suffices intro by_cases have simpa have simp


AEMeasurable.isLUB

classical nontriviality haveI rcases simp exact let let have intro simp split_ifs have ext simp_rw rw exact exact refine exact


choose suffices have rw exact have choose have intro rcases refine have exact refine have exact exact


by_cases rcases have rw refine have refine obtain refine exact refine simp push_neg exact


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


Measurable.iSup

rcases simp have have apply intro apply simpa intro apply simpa


Measurable.biSup

haveI by_cases have simp exact have simp apply exact


AEMeasurable.biSup

classical let have intro simpa refine have filter_upwards exact


Measurable.liminf'

classical measurability true which valid have rcases simp by_cases simp_rw simp_rw have let have have rw exact refine let let have set change let have intro by_cases rcases rcases exact exact have ext have split_ifs have simp have simp rw apply apply exact


have rw rw preimage_univ, exact exact have rw rw congr ext simp obtain simp simp refine have exact exact have rw preimage_iUnion, intro wlog exact refine calc f intro exact rw


rw refine le_antisymm rintro have simp rw exact


rcases rw have ext1 exact rw change exact


rcases have set have classical set refine unfold simp_rw split_ifs simp_rw exact exact exact


refine have ext split_ifs simp rw rw exact have refine exact induction bot coe top simp_rw apply rwa


refine exact exact exact simp_rw exact simp_rw exact


let let have ext1 simp exact let have refine exact exact have refine exact refine exact have refine simp refine exact rw


simp tendsto_measure_Icc_nhdsWithin_right intro simpa


rw constructor apply filter_upwards rw simpa


rintro classical let let have have have have rw refine rw intro have obtain rw refine by_cases exact rw exact by_cases exact rw exact refine by_cases rw exact rw exact by_cases rw exact rw exact rw


simp rw refine simp intro classical refine by_cases simp convert simp simp grind


apply rw rintro simp exact refine refine refine rw exact subset_iUnion


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


rw simp ext1 simp classical specialize have simpa


rw obtain obtain classical refine refine exact exact exact


apply refine obtain exact refine refine refine simp forall_exists_index, rintro refine ext1 simp


ext simp refine rintro refine unfold rw exact


rw intro dsimp split_ifs subst dsimp exact exact


intro rw have abs_of_nonneg have rintro have linarith have calc simp set have refine rw have calc dist have have simpa linarith


unfold split_ifs cases positivity positivity


have wlog trans simpa gcongr simp rw grw have have simp mul_assoc, simp


cases simp rcases rcases have simpa piPremeasure] simp


classical rw rw sortedUniv_toFinset] exact


refine intro rw rcases apply intro simp_rw refine simp rintro rintro


refine rw apply haveI simp_rw suffices clear rw intro exact


haveI haveI refine let refine calc measure_mono simp_rw iUnion_univ_pi


have exact refine rintro rw haveI simp_rw


ext classical rw smul_eq_mul, congrm swap refine simp


have refine rw swap exact have simp rw congr rw


let refine rw let have ext simp refine intro rw simpa


refine let have have ext simp refine rcases simp


constructor rintro obtain refine simp rw intro apply


constructor intro suffices exact rw refine exact


constructor intro rw rcases refine rw exact exact rintro rw exact


MeasureTheory.AnalyticSet.iInter

rcases the choose let let have apply intro exact haveI let have have apply rintro refine have rw exact intro have intro rw exact choose have refine simp refine exact rw exact


MeasureTheory.AnalyticSet.iUnion

coincides choose let let have have rw exact


obtain exists_countable_basis haveI have apply exact choose obtain exists_polishSpace_forall_le refine have exact


choose refine refine exact simp_rw intro apply apply refine exact


images not points in and by_contra have x y intro contrapose intro rw refine exact let have rintro rcases exact choose let let have simp have induction zero succ simp have intro apply rfl intro have apply rw exact rw have intro apply rfl intro have apply rw exact rw set set have intro convert rw intro rw exact rw intro rw exact obtain apply exact letI obtain apply exact obtain apply exact obtain exists_pow_lt_of_lt_one have refine rw apply intro rw exact refine change rw apply intro rw exact hz.trans_lt exact


are measurable. is straightforward. to and separating the the contained contradiction letI obtain exists_countable_basis haveI let have intro apply exact choose let closure obtain exists_seq_strictAnti_tendsto let suffices have intro refine refine exact have intro refine exact rw exact apply rintro refine obtain apply exact have apply convert ring refine refine apply refine apply exact apply exact intro have simpa choose have intro rw grind choose have intro rw by_contra have haveI have haveI exact have have refine rcases calc dist haveI let have suffices rw exact mem_range_self by_contra obtain obtain apply exact obtain haveI simpa have rw apply intro calc dist have closure_mono exact


refine borelize obtain rw exact infer_instance


many let have let have have rw apply obtain exact have rw apply apply intro contrapose wlog have exact intro exact exact


the let have have rw congr ext simp tauto rw apply apply intro simp exact


MeasurableSet.isClopenable'

letI obtain refine constructor rw infer_instance


by_cases cases obtain refine letI haveI apply exact refine apply exact refine rw exact


obtain simp_all borelize letI let have toIsCompletelyMetrizableSpace let have convert refine exact


obtain simpa borelize let rw let have have ext by_cases rw rw rw refine measurable_const rwa let have refine rintro by_cases obtain simp_rw exact simp_rw exact


cases inl h suffices simp simp intro simp obtain rw have simp inr have rw exact


classical let suffices constructor have exact have exact


MeasureTheory.IsProjectiveLimit.unique

haveI refine ext_of_generate_finite obtain rw


obtain obtain classical let let have have have have have rw projectiveFamilyFun_congr cases inl inr rw rwa


by_contra suffices intro wlog exact rcases simp specialize have have rw rw exact simp specialize replace exact


have have simpa by_contra rcases have have conv_rhs exact obtain have simpa rw exact rcases exact rw have exact


the induction let have rw have simp intro exact suffices rcases exact exact intro have k j k intro rw have simp simpa choose let have intro rcases simp simp have intro rcases simp simp have intro have rw rw have simpa notMem_of_lt_csInf exact have p.r p.r intro have have constructor have simp simpa apply have exact let apply refine simp rcases rw exact p.r_le let r rpos h intro wlog exact have rcases have rw exact exact hlast intro have have exact inter intro have have have convert exact


cases refine rw simp let τ one_lt_tau let refine intro obtain simpa obtain simpa wlog exact replace let have have rw apply refine simp intro exact simp specialize contrapose simpa refine obtain simpa p.mem_iUnionUpTo_lastStep simp exists_and_left] exact


classical rcases have refine simp simp cases simp exact have rintro inhabit exact obtain let r rpos r_bound r_le rcases have intro refine have exact let have refine intro obtain have simpa refine simp exact have calc simp rw simp finiteness conv_lhs apply obtain apply exact replace apply apply rw conv_lhs exact have have rw exact exact obtain have exact have exact refine simp intro simp suffices rw exact rw swap exact omeas.nullMeasurableSet calc μ rw gcongr rw apply rw have exact exact intro apply intro obtain simpa obtain simpa have exact


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


theorem. ensure measure disjoint measure completing classical obtain have choose obtain t0.Countable t0 μ exists_disjoint_closedBall_covering_ae let have obtain obtain simp not_false_eq_true]) have intro rcases rcases exact choose let r rpos r_bound r_le obtain range exist_disjoint_covering_families have intro apply have exact let have intro have simp intro refine rw exact simp refine exact simp intro exact intro cases inl rw exact inr hx have simp rcases exact simp intro by_cases obtain have simpa simpa refine simp exact have simp exact obtain refine rwa have calc haveI rw exact exact apply simp intro apply have calc have let exact haveI rw exact exact apply simp intro exact calc gcongr apply gcongr simp


intro simp obtain filter_upwards apply exact exact


contained i.e., borelize let let let have set have rintro apply rw convert norm_num have refine apply calc δ have calc rw have simp simp have have have simpa exact


classical subsequence, by_contra set have intro rcases rcases obtain have rcases exact simp exact exact choose have obtain exists_seq_strictAnti_tendsto have intro simp forall_const] obtain refine simp exact have have rw exact rcases have intro by_contra have simp exact let have have simp true_and] have simp forall_apply_eq_imp_iff, intro have exact have rw exact


classical have intro by_contra have simp linarith let have have simp true_and] have simp forall_apply_eq_imp_iff, intro have exact have rwa


have simpa have have have have calc have have suffices have intro rw exact rcases apply exact rw apply exact


have simpa have have have have rcases apply simpa have rw exact have calc have rcases have calc a.r calc a.r gcongr exact set have calc a.r gcongr have rw field_simp linarith linarith


have simpa have have have have apply intro change rw exact convert rw have set have set have calc nth_rw rw div_mul_cancel₀ rwa have calc a.r rcases calc a.r rw calc a.r have calc conv_lhs rw congr field


let have intro simp split_ifs by_cases refine wlog rw rcases simp_rw exact have rcases simp_rw exact have simp_rw exact


doubling only let have have intro apply obtain refine exact exact


let simp true_and, and definition. by_cases swap left small, and rcases refine constructor apply rw linarith have apply linarith have apply exact apply exact refine have apply have have linarith apply refine exact


refine filter_upwards exact rcases simp have rcases have exact have replace replace apply rintro replace simp linarith


set simp change let have intro rw simp rcases exact refine calc μ


apply obtain exists_isOpen_le_add let have apply have apply rintro exact haveI calc ρ rw


have intro set change obtain apply calc μ conv_lhs gcongr apply simp rw gcongr refine intro rw simp exact obtain exists_seq_strictAnti_tendsto have filter_upwards intro refine obtain obtain filter_upwards intro grw gcongr exact


apply obtain refine let by_contra apply calc ρ


obtain have have intro lift lift apply simp mem_compl_iff, intro apply refine simp simp mem_compl_iff, intro apply exact have filter_upwards intro exact


everywhere. have the its is way this let let let let refine exact exact intro by_cases refine exact exact intro by_cases refine exact exact suffices have toMeasurable simp inter_self] refine exact exact simp_rw refine calc μ μ measure_union_le have simp intro have apply exact have apply exact have ρ p calc ρ measure_toMeasurable_add_inter_left refine have tendsto_nhds_limUnder have apply rw refine simp simp have ρ calc conv_rhs rw rw refine intro have tendsto_nhds_limUnder have apply rw exact conv_rhs rw exact by_contra apply calc ρ p gcongr suffices simp exact apply rw apply exact


let have suffices calc ρ refine have apply rw refine simp


let have suffices calc refine intro have apply rw exact


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


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


ext1 refine have refine exact simp simp simp refine filter_upwards exact have refine simp simp refine filter_upwards exact


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


let have filter_upwards rw apply filter_upwards rw


have convert apply exact filter_upwards rw convert ext1 congr apply exact


desired lemmas above let rcases have simp_rw intro apply refine exact apply calc lintegral_mono haveI simp filter_upwards have obtain specialize simp apply filter_upwards v.eventually_filterAt_measurableSet congr apply simp apply obtain simp_rw have exact filter_upwards apply calc apply simpa gcongr rw exact simp gcongr


have filter_upwards x apply intro congr apply apply filter_upwards rw


rcases have intro apply exact filter_upwards obtain apply filter_upwards v.eventually_filterAt_measurableSet congr refine rw


filter_upwards have simp apply filter_upwards simp have simp_rw exact dsimp rw simp


showing density since is measure sets since the set set let suffices rwa intro set by_contra obtain d replace obtain simp obtain have tendsto_atTop_atTop.mpr replace replace replace intro specialize rw rcases specialize rw exact simpa mem_iUnion₂.mp choose let have suffices obtain replace simpa le_of_tendsto exact refine replace let let have have have apply rw refine change rw refine simp exact have hj refine change rcases apply rw replace obtain replace rw exact have grw rw grw replace rwa


let let have replace refine rw exact simp_rw rcases apply change refine exact simp have exact


refine rw apply change refine nlinarith exact


let have refine replace simp have blimsup refine replace simp rw exact


refine filter_upwards intro filter_upwards rw exact


as the there intersects family intersect that intersects let u u.PairwiseDisjoint obtain refine refine simp refine obtain exact refine by_contra have intro by_contra rw obtain exact lt_irrefl let have let have refine rcases exact obtain have rcases refine simpa have rw conv_lhs gcongr rcases rcases exact clear have refine rw exact exact intro by_cases rcases rcases exact simp rcases refine calc δ rw exact


abstract such so in an enlargement strategy, use the classical have refine refine exact choose let obtain have intro apply have refine exact have have u_disj.countable_of_nonempty_interior ht refine refine measure_null_of_locally_null let have ha.1 obtain have intro apply refine apply exact set have refine rcases exact rcases refine refine apply have linarith have have by_contra rw rw exact obtain obtain exists_lt_of_lt_csSup rcases exact refine apply apply rw linarith intro refine apply have linarith refine nonpos_iff_eq_zero.mp have calc rw exact obtain haveI simp have intro set have have simp intro have simpa have apply exact obtain obtain hf have refine refine exact closedBall_subset_closedBall obtain have refine rw exact let have intro have have apply refine exact simpa let have rcases have have simp linarith suffices exact haveI calc μ


suffices exists_disjoint_covering_ae intro specialize rw obtain exact


simp split_ifs exact have set simp_rw rw


rcases haveI have choose have intro contrapose have have obtain rcases exact use have have have linarith intro apply calc have have filter_upwards exact


simp_rw rw intro let have have have have refine rw exact rwa contrapose calc b rw exact


let suffices haveI refine rw rw exact rw rw exact


rcases refine refine intro exact intro rw exact


let suffices haveI refine intro rw rw exact intro rw rw exact


obtain haveI have rw exact have suffices refine refine intro unfold rw rw refine exact intro rw rw rw exact


have let have refine refine exact intro rw exact


apply let suffices have simp_rw exact have rw apply intro exact intro simp gcongr exact


rw push_neg constructor intro exact intro by_cases have apply exact simp by_cases have obtain simpa exact obtain have ext1 simp_rw constructor obtain obtain rw intro exact


have intro let have have calc simp rw refine rwa have have simpa obtain exists_seq_strictAnti_tendsto let have have intro simp have have tendsto_const_nhds.add simp exact have have simp exact this.eventually_const_le apply exact refine calc μ


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


refine simp intro rw refine calc refine calc intro simp_rw


have rwa refine refine exact rintro exact


classical haveI have intro by_cases rcases exact refine exact choose let have intro exact let have let have calc μ refine refine haveI apply gcongr exact have have have change convert ext simp filter_upwards apply intro by_cases swap simp simp contrapose obtain dense_iff_inter_open.1 have refine refine exact intro obtain dense_iff_inter_open.1 refine have simp exact


obtain have apply rintro lift lift exact


simp simp convert simp congr ext simp simp simp


AbsolutelyContinuousOnInterval.smul

obtain obtain unfold apply exact rw filter_upwards simp gcongr trans exact simp gcongr rw gcongr exact rw grw gcongr rw exact


rw intro refine calc apply intro have apply rwa


wlog specialize rwa rw rcases simp rw obtain have linarith obtain set have dsimp convert have apply apply simp refine linarith have eVariationOn convert simp simp norm_cast have simp intro obtain have apply constructor have intro constructor rw convert rw suffices convert rw congr rw linarith linarith have rw simp_rw have rw convert simp simp intro suffices apply convert convert rw convert norm_cast simp


have let obtain change refine have rw exact rw exact


intro let let have change rw refine intro rw have specialize rwa intro rw push_cast have lpMeasToLpTrimLie_symm_toLp rw rw exact h_add change exact


intro suffices from intro let have have let have have have refine suffices exact let have have rw refine rw refine rw exact have have let have have rw refine rw refine rw exact have have have haveI this.mono rw rw exact


intro let have refine change refine intro rw refine exact intro have have specialize refine exact


rw by_cases rw by_cases rw exact rw exact rw exact


by_cases swap by_cases swap rw split_ifs exact exact exact


by_cases swap have rw rw simp rfl have obtain rw have simp_rw rw rw exact


by_cases swap by_cases swap refine rw exact


classical induction empty insert rw exact


by_cases swap by_cases swap refine rw refine refine simp


by_cases by_cases refine exact exact calc exact simp simp


by_cases simp by_cases rw simp by_cases rw simp obtain simp replace rw refine rw


ext1 grw condExpIndL1Fin_ae_eq_condExpIndSMul] rw rw rw push_cast rw grw rfl


by_cases swap simp_rw exact by_cases rw exact rw exact


refine intro simp_rw rw exact intro simp_rw rw hx)] rw simp_rw rw integral_add exact exact


refine intro rw exact intro rw exact have condExpL1CLM rfl rw refine exact


let have rw refine condExpL1CLM intro rw condExpL1CLM_indicatorConstLp] exact intro rw push_cast rw refine refine exact refine exact


let let have have have have refine dsimp simp_rw rw refine exact exact rw exact intro rw exact


suffices rw refine dsimp rw rwa refine exact refine refine rw refine dsimp rw simp exact


refine have refine refine dsimp rw classical simp_rw split_ifs rw simp


have exact have refine refine intro rw exact intro rw inner_condExpL2_left_eq_right, setIntegral_congr_ae exact refine exact


rw integral_sub refine rw exact intro simp_rw rw have rw setIntegral_congr_ae exact


refine intro rw integral_condExpL2_eq exact have rw refine exact


ext1 refine have rw refine filter_upwards


have aestronglyMeasurable_condExpL2 rw exact


have aestronglyMeasurable_condExpL2 refine refine refine rintro refine refine rw exact intro rw have filter_upwards rw exact


by_cases swap by_cases swap haveI have rw exact by_cases swap refine exact exact intro rw refine filter_upwards exact exact


by_cases swap by_cases swap haveI have rw refine calc s.indicator s.indicator filter_upwards classical refine have refine exact rw filter_upwards by_cases simp simp rw refine exact rw


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


have intro ext by_cases apply simp rw refine filter_upwards simp simp have calc μ simp_rw obtain obtain exact condExp_add hg) hg) m


let have by_cases simp have have rcases exact have have refine exact exact rw refine tendsto_condExp_unique exact exact filter_upwards exact filter_upwards exact exact fun_prop refine grw refine grw intro refine nth_rw exact exact


by_cases by_cases swap obtain simp_rw obtain suffices rw filter_upwards obtain have simpa exact refine suffices refine filter_upwards rw suffices refine filter_upwards rw filter_upwards rw have constructor rw exact refine filter_upwards by_cases


refine exact intro conv_rhs rw rw setIntegral_trim exact exact


by_cases swap by_cases swap by_cases swap calc eLpNorm refine filter_upwards x exact rw integral_norm_eq_lintegral_enorm simp_rw rw refine have rw exact filter_upwards exact


by_cases swap simp_rw positivity by_cases swap simp positivity have rw refine have refine rw simp rw refine simp_rw


by_cases swap simp_rw exact by_cases swap simp_rw filter_upwards rw exact by_contra change simp suffices refine exact refine simp_rw exact simp refine refine lt_of_le_of_lt refine rw exact


let have measurableSet_le have refine uniformIntegrable_of by_cases rw refine one_ne_zero).2 filter_upwards simp obtain set have have intro have rw convert mul_meas_ge_le_pow_eLpNorm rw rw simp_rw refine rw exact refine have rw exact


obtain refine refine intro have rw exact intro have rw exact


suffices have intro rw rw exact have intro rw exact exact


rw have intro rw rw refine exact have intro rw rw refine exact have intro rw rw integral_trim integral_congr_ae exact exact


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


by_cases have rw rw simpa obtain ext rw simp


by_cases swap by_cases swap apply apply intro repeat apply filter_upwards


by_cases simp_rw by_cases simp_rw apply apply intro simp rw repeat grw simp


by_cases swap by_cases swap refine intro simp rw repeat rw


by_cases swap by_cases swap refine intro simp rw all_goals


by_cases swap by_cases swap refine intro simp rw


suffices rcases exact apply rotate_left rintro exact rintro exact intro rcases obtain exists_eLpNorm_indicator_le have obtain ht.exists_isCompact_isClosed_diff_lt have have rw exact obtain rcases have convert simp refine rw contrapose exact


have have have rcases change refine rwa positivity


suffices rcases exact apply rotate_left rintro refine let let exact exact intro rcases obtain exists_eLpNorm_indicator_le have obtain ht.exists_isClosed_diff_lt have have rw exact rcases have convert simp refine exact


have have rcases simp let refine suffices rintro have obtain simp specialize simp have have simpa simp_rw suffices intro convert field_simp intro have refine gcongr have refine specialize rw exact have refine specialize rw exact have rw exact rw integral_sub calc symm simp_rw refine exact nullMeasurableSet_lt gcongr refine exact exact refine rw convert hF_bounded simp ring rw gcongr grw have l suffices l refine rw exact simp exact replace simp_rw simpa have filter_upwards


intro by_cases have refine intro simp gcongr simp exact


MeasureTheory.TendstoInMeasure.congr'

intro suffices rw exact filter_upwards refine filter_upwards rw change rw


refine by_cases simp lift rw obtain rw rw obtain refine suffices rw intro rw exact


first doesn't have obtain refine rw positivity simp set use let have set have refine simpa have refine rw simp obtain obtain refine specialize have nth_rw rw mul_assoc, gcongr simp omega all_goals exact rw refine rw exact


refine rw by_contra obtain obtain obtain obtain exact obtain have exact


refine replace simp rw intro refine refine rw convert simp simp simp


refine simp rw intro specialize refine simp have refine congr simp


simp_rw rw refine simp push_neg rintro refine obtain exact


rcases have rw exact rw refine tendsto_measure_iInter_atTop


refine le_trans simp_rw rw intro rw exact


rw intro obtain rw refine simp exists_and_left] obtain specialize rw push_neg rw exact


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


let induction const obtain obtain obtain classical choose refine ext rw simp_all


bergelson

obtain refine hu.preimage measure_mono obtain exact


close enough sequence and rcases refine simp obtain obtain exists_seq_strictAnti_tendsto let have intro obtain have rw refine simpa rwa obtain refine simpa obtain obtain refine intro calc congr simp abel refine rw exact rw gcongr have rintro refine obtain have apply have apply apply exact apply exact have have have filter_upwards intro exact exact rcases let closure closedBall have intro have refine calc dist linarith have obtain haveI have rcases rcases exact inhabit exact refine obtain obtain have obtain exact obtain hF apply simp exact


apply let obtain have have apply exact have apply filter_upwards rw have convert exact have exacts have exact have filter_upwards intro simp have intro have rintro rw apply apply simpa rw calc simp abel have rw singleton_add_closedBall_zero, rw calc μ simp ring have filter_upwards rw obtain t.Countable t haveI calc μ rw apply rw exact gcongr have apply apply simp rw exact


apply rcases filter_upwards simp have let have simp exact obtain have addHaar_image_le_mul_of_det_lt rcases exact have by_cases simp simp apply simpa have have rcases simpa refine refine simpa simp exact filter_upwards intro have let suffices change rwa apply simpa simp exact


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


have apply refine refine exact simp apply filter_upwards intro rw exact


rcases have apply have rw refine apply exact have setLIntegral_congr rw intro exact


obtain classical refine refine have exact have set have rw exact rw have ext exact rwa


rcases have have rw have rw have apply rw have refine exact have union_ae_eq_right_of_ae_eq_empty exact rw have let have have apply simp rw rw exact


rcases have have have have exact simp have apply rw have refine exact have union_ae_eq_right_of_ae_eq_empty exact rw have let have rw apply simp rw


have simp_rw refine by_cases simp lift simp


and rw calc lintegral_mono_ae rw exact exact


have filter_upwards simp exact have filter_upwards refine conv_rhs exact exact


rw intro have simpa letI haveI refine refine simpa refine suffices grind


have intro rw calc refine exact exact rw exact


have rw rw one_div, simp refine rw finiteness


rw have suffices setIntegral_congr_ae have refine congr exact have suffices simp_rw suffices rw simp exact have refine rw exact rw


have rintro rcases rcases exact choose obtain have obtain exact refine rintro exact rintro exact


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


refine by_cases obtain obtain refine rw exact rw refine rw exacts


refine refine rintro exact rintro exact intro rcases rcases exact


refine rcases refine exact rcases refine apply simp convert ext simp


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


constructor intro exact intro obtain refine exact


borelize have have have rcases have apply apply apply exact


Monotone.locallyIntegrable

intro rcases obtain exists_Icc_mem_subset_of_mem_nhds have refine exact


have by_cases simp by_cases rw simp rw obtain simp rw simpa


refine by_cases simp by_cases simp rw finiteness


rcases simp by_cases simp have refine rw


by_cases simp by_cases simp eLpNorm_exponent_top, have rw have have let exact rw swap refine rwa rw exact


refine by_contra have push_neg refine rw


obtain simp obtain simp exact let calc eLpNorm eLpNorm_mono_enorm


MeasureTheory.MemLp.piecewise

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


by_cases simp by_cases simp exact simp_rw congr apply have simpa


refine refine by_cases simp rw refine simp


obtain simp obtain simp exact rw refine simp_rw norm_cast exact


simp_rw rw simp_rw apply have have simp simpa


have by_cases by_cases have simp hp', rw exact have simpa simp_all have simp_rw rw simp_rw apply have simpa


rw lintegral_indicator refine filter_upwards by_cases simp gcongr rwa simp


rcases use simp obtain apply exact simp refine rwa simp


by_cases have simp have have rw one_mul] exact


apply meas_ge_le_mul_pow_eLpNorm_enorm simp simp


have by_cases rw have let have repeat rw let have calc


have refine have exact rw nth_rw rw gcongr rwa


by_cases simp rw have have by_cases simp by_cases simp rw have refine congr exact have have rw have exact


obtain by_cases rwa rw refine by_cases have rw rwa have by_cases rw rw refine refine exact have by_contra have rw exact have rw rw exact


have apply apply contrapose exact rw have exact


calc eLpNorm simp rw gcongr obtain simp rw simp_rw exact obtain simp_rw rw simp apply filter_upwards gcongr exact


calc eLpNorm simp gcongr refine gcongr simp simpa simp rw gcongr simpa


have obtain simp_all have exact obtain simp_all have exact obtain obtain have have rw simpa have obtain have rw exact all_goals first positivity finiteness


by_cases simp by_cases simp have repeat exact


rcases simp rcases simp convert have simp simpa simpa


have nhdsWithin_le_nhds simp rcases refine calc eLpNorm


haveI revert refine simp intro simp exact


simp_rw suffices ext1 suffices refine exact


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


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


refine apply convert ext rw mul_inv_cancel₀, simp rw


suffices rw refine dsimp rw refine exact


rw rw refine have have have refine all_goals rw simp_rw


obtain have filter_upwards exact calc refine obtain exact


rw refine apply filter_upwards hx₁ rw exact


let have refine rsuffices exact obtain let have have change rw exact have rwa have rw exact let refine specialize rw dsimp rwa rw exact


have rw simp_rw have ext1 congr simp_rw rw rw exact exact rwa


have suffices rwa have intro rw simp_rw rw have refine have have refine all_goals rw refine exact


have have have refine rwa have refine exact refine rwa


by_cases simp_rw have simp_rw exact simp_rw refine refine intro specialize rw ofReal_norm_eq_enorm] exact rw exact have rw exact have intro specialize rwa exact


rw intro have suffices exact obtain refine have refine refine simp_rw exact refine refine refine exact


refine rw obtain specialize have rw refine rw constructor refine have rwa exact


Filter.Tendsto.compMeasurePreservingLp

have replace tendsto_subtype_rng.2 convert


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


ext1 refine have rw refine refine dsimp rw simp_rw by_cases


by_cases refine simp simp obtain classical let have intro unfold refine by_cases have simpa simp grind have refine exact simp have obtain refine have rw have simpa have filter_upwards exact


refine rw refine split_ifs exact exact refine rw have refine rw


simp rw intro split_ifs simp calc indicator_le_self exact


rw refine intro rcases have refine rw exact exact


refine simpa intros assumption intro refine rw exact intros rfl


simp refine rcases rw refine congr grind


refine calc f.lintegral simp gcongr exact


classical constructor refine exact intro rw exact


refine rcases simp simp by_cases subst simp exact


MeasureTheory.SimpleFunc.induction

classical generalize rw induction empty rw convert ext simp insert have let have apply simp rw diff_eq_empty.mpr, rw convert exact rwa convert ext1 by_cases simpa simp rw rintro by_cases


MeasureTheory.SimpleFunc.induction'

let classical generalize rw induction empty rw convert ext simp insert have let have apply simp rw diff_eq_empty.mpr, rw convert exact rwa convert ext1 by_cases simpa simp


classical induction hs simp rw exact hf have ext by_cases simpa simpa rw exact


induction zero succ simp split_ifs exacts


induction zero succ simp split_ifs rcases exacts push_neg rcases rcases exacts


have intro apply exact intro exact intro refine by_cases simpa simp apply simpa rintro obtain mem_nhds_prod_iff'.1 refine exact obtain refine by_cases simpa have contrapose rw exact simp


letI obtain exists_seq_strictAnti_tendsto have h'f.exists_simpleFunc_approx_of_prod choose have intro rw apply rw exact apply


by_cases simpa have suffices simp convert simp have simpa have have have filter_upwards have convert simp simpa


refine suffices have convert ext simp have have simp fun_prop refine rw convert simp have filter_upwards convert rw positivity calc eLpNorm eLpNorm_mono_ae


borelize let rsuffices refine suffices apply filter_upwards simpa have have have rcases rw exact


have have rw by_cases swap suffices ext1 rw refine rw exact specialize rw cases inl inr cases inl refine simpa inr


by_cases rw by_cases rw refine rw refine by_cases simp refine exact


MeasureTheory.Lp.simpleFunc.induction

suffices rw apply clear apply intro by_cases convert ext1 simp exact intro obtain exact


borelize apply intro rw have haveI refine toLp convert rw


rcases change classical refine simpa filter_upwards simpa


MeasureTheory.MemLp.induction

have apply intro by_cases subst have exact intro rw exact have intro exact ae have exact


rcases rcases exact suffices obtain rcases rcases refine convert hg).le simp apply intro rcases rcases rw refine convert ext simp indicator_zero', have rcases rw exact intro obtain rw rcases rcases refine convert rw abel


ENNReal.hasMeasurablePow

refine simp_rw refine exact simp_rw refine exact


have refine filter_upwards by_cases simp simp suffices exact


constructor intro exact intro refine have have exact


refine rintro rcases simp rw exact obtain refine exact


letI borelize refine hg.continuous.comp_aestronglyMeasurable let have have exact rcases exact


borelize refine exact rcases have choose refine filter_upwards apply filter_upwards


obtain classical refine exact rw simpa apply filter_upwards exact


refine refine have rw rw filter_upwards intro simp have rw rw filter_upwards intro rw simp


borelize refine have choose refine simp intro filter_upwards exact


have simp by_cases rw rw have convert rw refine calc refine rw exact exact rw refine have rw exact nth_rw refine exact


simp refine by_cases simp exact rcases rw simpa rwa rw rw rwa


rcases simp refine refine let have have let have conv have ext1 exact obtain exact


haveI let have let let have intro rw refine simp refine simp_rw classical refine rw swap letI rw exact refine have rwa by_cases swap rw exact have obtain obtain rsuffices exact rsuffices exact rw trivial refine simp_rw rw intro obtain refine rw exact


have apply rintro apply filter_upwards apply exact


letI borelize refine let have isClosed_range rw exact have exact have rwa


borelize refine exact rcases have apply rintro rw apply filter_upwards apply exact


refine intro by_cases rcases simpa simpa


nontriviality suffices from this ext by_cases lift simp lift rw exact


let refine change induction const simp_rw exact


let have intro rw have intro rw refine by_cases simp_rw exact simp_rw exact


have rw refine rwa obtain let measurableSet_fiber rw refine exact by_cases suffices rw exact ext1 rw exact suffices rw exact ext1 simp not_and, refine rw exact finite_range exact


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


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


borelize obtain have refine exact let have rw exact refine have refine have rfl rw exact have apply rintro simp exact have rfl simp_rw refine exact


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


borelize haveI let refine have exact intro apply apply simp


by_cases subst rcases refine intro exact rwa


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


intro rw obtain let have obtain refine by_cases exact exact


rw intro by_cases rw by_cases rw have obtain obtain have have set have have have have have rw obtain use have have calc eLpNorm eLpNorm_indicator_eq_eLpNorm_restrict have have calc eLpNorm rw have have calc eLpNorm rw have have calc eLpNorm rw apply calc eLpNorm exact apply


have have have have have have have have set set have have apply exact


refine obtain exact tendsto_Lp_of_tendsto_ae let let hms'⟩


MeasureTheory.UnifIntegrable.add

intro have obtain obtain refine simp_rw refine have rw rw exact add_le_add


classical intro obtain refine filter_upwards simp_rw


have obtain refine refine filter_upwards simp


have refine rw have simp have intro rw refine rw exact finiteness rw refine have simp_rw exact rw exact


by_cases exact by_cases subst obtain refine simp obtain refine rw conv_rhs rw convert rw have rw by_cases rw rw rwa rw simp rw rwa


by_cases refine rw simp ext rw exact refine by_cases simp rw have filter_upwards exact refine rw rw refine rw simpa


obtain obtain eLpNorm_indicator_le_of_bound intro rw split_ifs exacts refine rw rw refine exact exact rw refine rw exact ext by_cases rw rw


have obtain obtain refine convert rw exact


intro by_cases obtain obtain refine convert exact