simp_rw refine exacts refine linarith grind


rcases subst rfl refine rw rw exact linarith


rw by_cases simp simp none, simp rw exact some termination_by


refine rcases refine calc dist dist_birkhoffAverage_birkhoffAverage_le gcongr refine simpa


apply exact intro have convert rw exact mul_zero


obtain isCompact_Icc.exists_isMaxOn refine apply simp exact


obtain isCompact_Icc.exists_isMinOn refine apply simp exact


obtain by_contra exact obtain by_contra exact exact


constructor intro simp exact rintro exact


have refine rintro have rw calc f₂ simp set set have have refine simp exact simp exact exact


simp refine intro refine nth_rewrite rfl intro exact


intro by_contra obtain rw have rw simpa set have have have simp_rw rintro apply simp_all have simp refine simp cases inl inr refine rwa


instErgodicSMulOfIsMulLeftInvariant

refine suffices simp exact intro obtain refine rw exact exact simpa


measure there of must set set have have rw rcases right obtain d exists_mem_of_measure_ne_zero_of_ae let replace let have have refine replace convert ext simp have hδ₀.mono simp apply exact suffices replace rwa refine have have have have have have rw exact rw volume_of_add_preimage_eq


set let have suffices replace have conv_rhs rw ext simp neg_smul, abel


set by_contra obtain rw convert rw have set have rwa exact have rcases refine simpa simpa


by_contra have simp exact rcases rcases exact


have h.ae_mem_imp_frequently_image_mem refine rcases exact


MeasureTheory.Conservative.iterate

rcases exact refine rcases rw rcases set have apply exact refine intro rw exact rwa exact


have rcases convert rw refine have constructor rwa set have refine convert exact rw intro by_contra obtain have apply refine rw simp rw simp


have have have obtain simpa wlog exact refine rwa


rcases convert refine rw calc μ.singularPart rw rw rw exact


wlog specialize refine apply exact refine set have have measure_diff_symm have measure_diff_symm suffices suffices contrapose apply calc μ apply rw finiteness exact


suffices refine conv_lhs replace simpa rw rintro change replace rwa


simp_rw refine obtain refine rw exact have suffices rwa zero_add, have rw refine exact


simp_rw constructor intro rcases exact intro rcases exact


ext simp frequently_or_distrib] contrapose simp rintro refine exacts rintro exacts


rcases let have let have have have rw rw simp_rw rw exact rcases let have have apply simp intro unfold gcongr refine all_goals have simp exact have have exact


rcases rw apply rintro use constructor all_goals intro have exact intro apply calc exact


simp intro rintro rcases rcases have ht₂.mono have l₁.mono have rcases exact rcases exact


rcases suffices unfold convert rw rw exact


apply apply rw exact apply apply rw apply rw exact


by_cases have have rw refine rintro rcases rwa exact rw nth_rw nth_rw exact rw simp


apply suffices from intro refine exact exact


classical rcases exact have have obtain rcases use simp exact one_le_pow_of_one_le have rcases inter_nemp exact obtain refine simp mem_comp] intro replace specialize specialize rw exact choose let refine rw have intro have intro have simp obtain exact choose simp refine rw apply simp


refine obtain rw simp have by_contra apply rw simp rw exact have rw rw simp exact


rcases rw obtain rw rcases simp obtain obtain rw exact


classical by_contra have intro specialize simp simp obtain refine rw rw exact apply rw exact_mod_cast


have have rw rw apply rw refine rw exact


obtain obtain apply apply rw exact_mod_cast


rw induction zero succ simp rw apply rw exact


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


refine rw intro have rw replace rw exact


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


classical rcases exact obtain rw apply rw by_contra obtain simp have refine refine exact rw apply rw refine exact x_uncov


apply obtain have apply exact apply apply exact


apply obtain apply have exact apply apply exact


Dynamics.IsDynCoverOf.preimage

classical rcases exact obtain choose choose refine simp map_apply, obtain refine rw exact


classical rcases exact obtain rw have rw exact


let apply refine iSup₂_le apply rw exact refine simp obtain obtain apply apply exact


classical rcases rw rcases rw obtain obtain rw apply rw exact


let let haveI let have haveI haveI exact


by_cases rw exact have have apply intro ext simp have intro lift exact obtain obtain rw


by_cases rw exact have mt by_cases rw exact have have have have apply intro ext rw have intro rw exact have intro have obtain use rw obtain obtain rw mul_right_inj


have by_cases simp have have obtain rw have intro rw exact let have rw have rw use rw have have rw pow_comp, have ext1 dsimp rw rw rfl


by_cases rw exact apply exact exact rw apply rw have rwa


solvableByRad.induction

revert suffices intro obtain convert exact apply exact intro obtain exact intro obtain exact intro obtain exact intro obtain exact intro obtain refine convert exact


solvableByRad.isIntegral

revert apply exact exact exact exact intro exact intro obtain refine rwa rwa


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


let let have rw splits_mul_iff let nonempty_algHom_adjoin_of_splits intro push cases inl inr have refine rw apply simp exact rw refine apply


solvableByRad.isSolvable

revert apply exact exact induction2 exact exact induction2 exact exact


have classical intro cases let have have have have let let have rw intro ext simp exact rcases refine simpa


classical have simp funext_iff, simp simp


classical have letI rw realize_genericPolyMapSurjOnOfInjOn] rintro exact


letI let rw rcases rw rcases rw have rw realize_genericPolyMapSurjOnOfInjOn] exact


rw finSepDegree, by_contra obtain refine exact


haveI rw apply rw conv_rhs exact conv_lhs exact


dsimp exact rw rw finSepDegree_eq_finrank_of_isSeparable]


haveI calc intro obtain calc calc intro let calc intro let letI uniq calc rw mul_comm rintro change rw


have let have simp that while let have intro calc eval simp split_ifs apply intro rw rw obtain apply rw have rw sum_congr change rw change apply show calc gcongr change calc totalDegree_sub


induction simp rename_i simp rw apply simp simp_all simp_all


let refine ext apply_fun conv_lhs conv_rhs simp apply apply rw have apply intro simp apply exact


have have have zorn_le₀ suffices by_contra obtain let let have let have lt_iff.mpr have simp_rw choose classical have simp_rw have rw exact


obtain refine letI letI have have obtain exact convert


have have rw obtain exists_algHom_adjoin_of_splits exact


let intro have have cases inr inl have have let have rwa have rw apply rw exact apply rw


rw rcases let have simp have simp have rw apply contrapose ext rwa


rw nontriviality have rcases rw have simp_rw have funext simp rw congr rw exact have rw have rw refine ext rw simp_rw


FiniteField.card

haveI letI obtain rw refine apply rintro rw have exact


classical obtain rw orderOf_dvd_iff_pow_eq_one] constructor intro intro simp_rw rcases rw


let map_one map_mul have calc suffices simp split_ifs exact rw show rw apply


by_cases simp classical have let have ext simpa isUnit_iff_ne_zero calc rw


classical have have rw intro rw rw apply rw convert rw


rcases subst change fin_cases use use let let obtain refine rw simpa


induction zero succ rw obtain rw rw refine simp_rw refine cases rw cases cases


rcases exact rcases exact have obtain rw refine rw replace contrapose rw rw obtain rw exact


classical obtain obtain have constructor rintro rw apply_fun push_cast exact subst rw have rw rw apply have obtain refine dsimp rw


apply simp constructor rintro rintro have refine


FiniteField.algEquivExtension

refine have have have have rw exact refine exact


GaloisField.finrank

haveI set have have have card_rootSet_eq_natDegree have rw suffices simp_rw rw exact rw suffices x rw simp_rw intro cases simp refine rintro simp rw dsimp rwa rw simp intro exact simp simp intro rw intro simp rw simp simp intro rw


FiniteField.algEquivOfCardEq

have have choose choose rw have have rw exact


FiniteField.ringEquivOfCardEq

choose choose choose choose have by_contra simpa rw haveI letI letI exact


have have have have have have refine refine exact rw exact


rw classical refine rw refine refine rw exact


classical rw intro refine simp_rw trans refine intro simp intro rw


cases refine classical refine exact ext simp rw aesop


let rw constructor intro exact intro refine refine rw


constructor intro exact convert simp⟩⟩ rintro rw exact


classical have refine rw rw rw rw rw suffices replace simp_rw refine change exact intro refine eq_of_sub_eq_zero refine ext conv_lhs rw congr skip ext rw rw conv_lhs congr skip ext rw change rw rw


have have have rw rcases right have rwa left have rwa


cases rw constructor exact apply exact rw exact


let let let have intro refine rwa intro obtain revert refine rwa


obtain let invFun map_mul map_add commutes have have have replace simpa rw rw apply exact


have classical suffices exact apply refine refine exact


have have rw exact have apply rw exact let change exact haveI have apply have rw apply intro rw exact apply rwa


haveI letI let have apply rw apply let suffices rw apply rw exact apply have rw specialize rw refine apply rw intro simp rw symm refine rfl


obtain let suffices rw constructor rw exact have rw rw sup_comm,


suffices fixingSubgroup_fixedField refine obtain refine rw rw exact obtain exact


Algebra.IsQuadraticExtension.isCyclic

have rw interval_cases simp_all exact exact


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


apply ext refine have apply simp intro apply dsimp nth_rw exact have apply simp simp intro have nth_rw exact


apply intro by_contra have rw rcases rw have let finiteDimensional isGalois have rintro have apply simp apply exact have rw have rw apply intro apply simp rcases have use simp mul_inv_cancel_left, apply intro simp have rw simp absurd apply use simpa not_not,


refine have rw rcases rw have let finiteDimensional isGalois have apply rw exact let exact


refine let let have have have have apply apply intro simpa inf_le_left intro apply simpa rw constructor simpa


have simp_rw refine have exact obtain obtain simp have have have obtain have obtain rw replace have rw obtain use simp


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


rcases have rw exact rw contrapose have exact


iterate induction induction induction algebraize have have have have ext apply


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


induction induction letI letI rw change rw rfl


constructor intro have have have rw exact intro use refine obtain have have rw exact div_mem


have adjoin_toSubalgebra_of_isAlgebraic apply_fun rw simp rw exact


let let let have apply_fun rw dsimp rw exact


by_cases have change rwa rw have show rw show


rw induction empty rw exact insert rw exact


simp_rw obtain classical refine simp_rw rintro exact


set set have refine rw rintro rw apply have apply rw erw rw exact have intro have rw simp_all refine simp_rw convert natDegree_le_of_dvd rw


induction zero succ obtain obtain contrapose rw exact let haveI refine have have exact


constructor rintro obtain rw haveI adjoin.finiteDimensional apply


have have have intro apply not_irreducible_C rw apply rw have have have suffices have let letI have refine rw exact have rw exact have g.map minpoly.eq_of_irreducible_of_monic have trans have apply rw restrictScalars_adjoin] simp rw exact simp have rwa


have rw congr exact rw congr rw rintro obtain simp exact


rw change apply rintro exact exact exact


rw rintro classical replace rw exact intro rw


replace obtain exact refine by_cases simp obtain rw refine let obtain exact


apply intro have rw exact rcases use rw apply rw clear induction


refine have have degree_eq_one_of_irreducible have rw exact


refine replace contrapose rw rintro obtain simpa exact


IsAlgClosed.instInfinite

apply intro set set have apply have rw unfold rw rw exact


IsAlgClosure.equivOfEquivAux

letI letI letI haveI haveI have have refine ext simp conv_lhs change rw


refine by_cases simp by_cases rw simp have classical simp refine by_cases have rw intro calc rootMultiplicity add_le_add simp


IsAlgClosed.equivOfTranscendenceBasis

letI letI have refine refine ext ext exact exact


obtain obtain have have rw lift_injective exact obtain exact


letI letI obtain obtain have have rw lift_injective lift_injective exact obtain exact


rintro let have rw have rw have apply simpa


refine have have ne_zero_of_degree_gt have have have rw aeval_C] replace rcases exact


by_cases rw refine rw rw refine rcases by_cases rwa rw subsingleton rwa


refine obtain obtain exact simp obtain exact


have rw exact have rw exact by_cases exact obtain use simpa


refine have have have degree_eq_one_of_irreducible have rw exact


refine let let have apply rw exact let let let have let have have let have exists_algHom_adjoin_of_splits refine rw rfl have cases have have exact simp_rw exact


obtain refine have ext rw sub_pow_expChar_pow_of_commute pow_mulRight, exact rw


obtain by_contra replace obtain have nh k obtain rw use change simpa obtain obtain have classical refine set by_cases convert lia suffices rw linarith set let have apply rw suffices rw set have apply_fun rw exact have rw have simp_rw have nth_rw rw apply_fun rw obtain apply_fun rw mul_assoc, exact


have have congr set set let let have have rw congr exact have obtain exact


rw constructor rintro exact rintro exact


rw intro have rcases let haveI refine simp not_forall] exact


ext simp constructor rintro change apply_fun rw exact rintro replace rwa


wlog rw by_contra replace obtain let replace rw exact let have let have classical rw rw rw congr exact


have rintro rw exact simpa irreducible_comp


induction zero one prime_mul rw apply intro have not_not.mp simpa congr_arg apply intro apply rw simp


letI letI have by_cases rw have rw rw separable_prod_X_sub_C_iff'] exact


have letI constructor rw have rw exact rw apply have rw


obtain rw simp autAdjoinRootXPowSubCEquiv_root, rfl


have rw obtain have have rw simpa obtain have simp_rw refine rw intro obtain rw one_pow, apply rw intro obtain have simp conv_rhs obtain rw exact


have refine simp intro refine rw exact exact


constructor rw have rw exact rw apply rw eval₂_X_pow,


obtain rw intro refine trans rw rw exact


have obtain rintro obtain rw have simpa apply_fun simp exact


have rw exact have suffices hg by_contra have have rw rw powerBasis_dim have hp.coprime_iff_not_dvd.mpr h exact


let let let have have suffices have have rw have exact


refine set let have rw congr ext simp exact refine ext simp_rw rfl


rw set have rw congr ext simp refine rank_eq_of_equiv_equiv ext simp_rw rfl


obtain apply let letI let let let replace simp_rw have i replace simpa change rwa


have by_contra rw exact have rw eq_neg_iff_add_eq_zero, exact


minpoly.unique'

nontriviality have obtain swap exact obtain rw have rw have have rintro exact apply_fun rw apply rw exact rw


nontriviality refine rw simp_rw intro rw rw rwa


refine obtain have rw apply refine rw exact


minpoly.irreducible

refine rw by_contra have rw rcases exact refine rw


intro induction h induction h simp_rw rw


simp_rw constructor rintro rw rintro induction h


minpoly.unique

have symm by_contra apply apply rw exact


minpoly.dvd

by_cases simp have rw by_contra apply exact


refine eq_of_monic_of_dvd_of_natDegree_le obtain rw refine rw


by_cases refine simp have have rw natDegree_comp, rwa natDegree_X_add_C, rw refine simpa


minpoly.neg

by_cases refine simp have have have have rw natDegree_comp] rw degree_eq_natDegree natDegree_mul simpa rw simp exact


constructor intro have rw exact rintro simp


refine simp intro rw intro rw simp_rw apply simpa


let let let have rw refine rw rw apply rw exact rw map_dvd_map rw exact


IsIntegrallyClosed.minpoly.unique

have symm by_contra refine refine exact rw


refine use have suffices apply convert rw rw convert refine have simp exact have simp false_or] exact exact


refine or_iff_not_imp_left.mpr rw rw exact


let let let apply rw map_scaleRoots simp_rw refine refine simpa exact rw mul_inv_cancel₀ refine nth_rw map_inv₀] exact


by_contra have induction zero succ intro rw refine exact apply rw exact lia


induction zero succ rw refine apply apply exact rw apply rw apply rintro rw exact


nontriviality classical apply rw rintro apply rw simp intro induction ind intro have coeff rw refine rw intro exact rwa


classical rw have apply intro simp eval₂_minpolyDiv_self, eval_X_pow] rw rw exact refine simp forall_true_left, refine intro exact rwa


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


classical let refine rw refine exact rw exact


rcases have rw exact refine haveI have let have rw obtain let rw refine rw letI let change rw exact rwa exact


refine obtain let have haveI refine exact simpa apply have refine rw exact have rw have rwa


let have normal_iSup have splits_of_splits obtain convert simp


refine let exact have intro rw exact simp rintro exact


rw rw exact splits_of_splits simp_rw refine rw refine refine rw


IsNormalClosure.lift

have refine nonempty_algHom_of_adjoin_splits obtain by_cases exact simp


have rw normalizedTrace_eq_of_finiteDimensional trace_trace, let have have have let rw normalizedTrace_intermediateField congr


apply_fun simp rw simp all_goals apply simp


PerfectRing.toPerfectField

obtain exact refine rcases assumption exfalso


PerfectField.toPerfectRing

refine rcases simp rw apply apply simp hp.ne_zero]


classical refine by_cases obtain simp_rw exact convert simp_rw exact


PerfectClosure.R.sound

subst induction zero succ rw apply apply


constructor intro replace induction rel refl symm trans obtain obtain exists rw rw rw simp intro obtain obtain obtain rw rw


PerfectClosure.natCast

induction zero induction zero succ succ rw suffices apply


constructor exact intro have rw have simp rcases exact


rw intro ext have change rootsEquivRoots rootsEquivRoots rw exact


by_cases have exact intro classical simp simp ext rw rcases haveI have x algebraMap rw exact haveI have x algebraMap rw exact


let have intro by_cases exact obtain hr hq) rw have have exact have intro by_cases rcases rw simp exact by_cases rcases simp exact have rwa exact


rw have let have use suffices letI rw suffices have apply exact exact apply rw


obtain use rw rintro by_cases rw exact obtain rw exact


classical let let classical let let obtain simp_rw push_neg exact


classical have have let let let let obtain let suffices use apply rw have rw exact rintro rw have have exact classical let let have have suffices have simp mul_div_cancel_left₀ rw exact have have apply rw add_sub_cancel_right, rw have rw exact have intro rw specialize hc have rw exact specialize hc rw exact by_contra apply apply simp ring rw trans dsimp convert simp congr


let obtain use apply rw have have dsimp simp have rw replace rw have convert apply rintro rw have have exact


rcases let have have intro obtain rw haveI obtain exact exact exact


wlog exact by_cases rw simp obtain refine simp obtain by_cases simp exact replace rw replace let refine have have have rw exact simp ite_false, exact intro simp simp


let have haveI adjoin.finiteDimensional have have le_top.antisymm rw exact


haveI rcases obtain exact apply rintro simp_rw exact


haveI obtain let let have fintypeSubtypeMonicDvd map_ne_zero let convert rw have rw apply_fun simpa exact


refine eq_of_le_of_finrank_eq letI rw exact exact


rw refine obtain exact h1.of_dvd have have by_contra refine rwa


IsPurelyInseparable.trans

obtain haveI rw intro obtain obtain refine rw


suffices intro generalize induction ind by_cases rw exact obtain obtain have rw obtain rw by_contra refine exact exact


by_cases rw refine have rw simpa rw simp


rw letI let exact j.injective.comp_left inferInstance⟩


nontriviality obtain induction zero add h have simp_rw exact tmul obtain use have rw rw refine rw subst have exact


let rcases exact obtain let have have have exact ringExpChar.eq


set set have rw rintro exact letI haveI haveI rw exact simpa congr_arg


classical rw intro let haveI let have exact


let haveI haveI obtain have obtain simp exact exact


set set let let have rw exact let letI letI haveI haveI change obtain have restrictScalars_injective conv_lhs rw adjoin_adjoin_comm] rw rintro obtain refine rw have rw rw


let obtain have have exact have ha.map have rw exact


unfold by_cases have rw cases rw div_eq_iff simp congr apply


unfold by_cases have rw cases rw div_eq_iff repeat congr apply


rw nth_rw apply intro simp simp by_cases simp pow_pos simp


classical induction have rw mul_comm apply apply exact exact refine exact


constructor rintro obtain use rw exact exact rintro exact


constructor rintro obtain use rw exact rintro exact


by_cases simp by_cases simp rw refine rw


obtain apply have simp dsimp convert rw ring exact


nontriviality rcases simp apply obtain refine rw calc simp ring simp sub_add_cancel]


classical exact rcases haveI have have contradiction haveI exact


replace induction rcases refine rw rcases rw rw have rw exact have have intro rw cases have rw exact rcases refine rw


revert wlog intro simpa intro rw rcases rw subst subst rcases rw rcases simp_rw exact rw constructor


refine exact not_isUnit_of_natDegree_pos simpa


classical refine rw obtain simp_rw exact


have rintro exact suffices map_injective apply change rw constructor apply rw rw exact exact exact


classical obtain use rw apply apply rw exact


separableClosureOperator

refine dsimp let have exact obtain exact


let have have have rw refine have lift exact let have refine have lift have apply exact convert have inferInstanceAs exact


by_cases rw wlog simpa rw natDegree_eq_zero] refine by_cases exact exact rintro exact exact classical simp_rw rw refine obtain exact rintro exact rintro obtain simpa


obtain cases zero simp_rw exact prime refine haveI rw exact


obtain exists_monic_irreducible_factor not_isUnit_of_natDegree_pos have obtain have classical have refine obtain rw natSepDegree_pow_of_ne_zero simpa


convert_to simp_rw refine obtain exact have refine natSepDegree_X_pow_char_pow_sub_C rw exact


haveI haveI refine obtain have rw use rw sub_pow_expChar_pow_of_commute apply_fun simp_rw rw exact


by_cases rw exact have finrank_of_infinite_dimensional halg rw exact


by_cases rw refine induction_on_adjoin simp have set rwa rw exact


wlog rw obtain have rw by_cases rw linarith rw refine induction_on_adjoin simp have congr_arg₂ set rwa


set let haveI let have clear_value have have have simp replace haveI haveI haveI haveI have rw change exact


refine have obtain rw refine specialize have rw exact obtain haveI obtain exact exact


have delta convert hF.map rw congr aesop


refine wlog exact have have rw refine rw simpa


by_contra have choose exact choose have classical replace simpa have mt simp_rw refine simp rw simp obtain let have ne_of_ne_of_eq hF'0) have have simp suffices have contrapose rw rw replace exact rw intro obtain refine conv_rhs


have have have simpa let obtain replace have obtain have have have refine let have have have open algebraAdjoinAdjoin have coeff_ne h.trans_lt hF₁irr contrapose have hp.ne_one obtain replace rwa minpoly.eq_of_irreducible eq_mul_inv_iff_mul_eq₀ map_eq_zero_iff


have refine rw adjoin_le_iff] rintro obtain exact exact


have refine have have rw refine rw intro obtain exacts obtain exacts


obtain obtain have rw exact obtain lift have exact have have refine apply simp


refine replace contrapose rw rintro replace simp not_true]


Polynomial.IsSplittingField.mul

constructor rw exact classical rw adjoin_rootSet,


ConvexCone.IsGenerating.isReproducing

rw intro have let add_mem rintro exact zero_mem obtain exact smul_mem rintro simp rcases refine rw simp obtain exact exact have let exact


Convex.toCone

apply rintro exact rintro have refine simp


rw constructor rintro exact rintro exact


ext simp refine rintro simpa intro simpa


rw have have have cases have refine classical rw


rw direction_affineSpan, constructor intro constructor intro rw have simp rw exact rintro rw rw refine rw simpa rw simp exact


apply convert simp simp_rw rw rintro suffices rw refine refine simp rw have have vectorSpan vectorSpan rcases have rw exact have rw exact have simp simp_rw rw simpa convert rw refine rw exact rw exact


obtain rw refine rw positivity positivity rw refine rw exact


have have refine rw rw rw rw rw by_cases subst exact by_contra rw angle_eq_arcsin_of_angle_eq_pi_div_two div_eq_zero_iff] simp rw simp exact


have have rcases exact nth_rw nth_rw rw exact


have have by_cases exact rw rw angle_eq_arcsin_of_angle_eq_pi_div_two angle_comm, angle_eq_arcsin_of_angle_eq_pi_div_two refine rw have rintro exact have rw rwa rw exact rw exact


rw have rw exact obtain exists_eq_smul_of_parallel rw rw rcases simp simp


have have rcases left rw right rw right rw left rw


by_cases let have have refine all_goals simp_rw obtain dsimp rintro exact exact have intro simp_rw obtain dsimp rw exact have have convert


simp_rw apply refine obtain rw nth_rw exact rcases exact exact


rw constructor intro by_cases by_cases refine rw rintro rwa


rw refine rcases by_cases obtain exact by_cases obtain refine simp rcases by_cases rcases rw exact simp exact


rw constructor rintro simp rcases simp rintro obtain have obtain apply simpa simp


rw nth_rw rw have rintro rw exact have convert simp


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


by_cases by_cases refine intro rw exact h


by_cases simp by_cases simp refine rw simp have rw simpa


by_cases by_cases rw refine rwa convert simp


simp_rw refine rcases change refine change rw refine obtain rw rw simp rcases change refine change rw refine obtain rw rw simp


by_cases rwa have intro rwa let have have refine all_goals simp_rw obtain simp intro simpa simpa have have convert simp have convert


by_cases have conv_rhs rw rw rcases rw rcases rw rcases rw nth_rw rw rw or_iff_left rw exact exact


by_cases simp by_cases obtain simp simp by_cases rw have simp intro apply by_cases rw rw simp have revert generalize generalize decide have rcases rcases rw obtain obtain simp_all rw obtain obtain simp_all


rcases have rw add_comm, simpa rw rw mul_div_assoc, rw have rw rw div_self


haveI obtain use apply apply apply intro symm fin_cases simp have simp simp


rw let have rw have rw rw ring_nf rw sq_eq_sq₀ exact


have refine have rwa neg_eq_zero] have rw have simp_rw exact


obtain rw nth_rw rw mul_div_cancel_right₀ simpa


set let have rw simp⟩ have convert rw angle_eq_abs_oangle_toReal congr simp


have let let rw refine simp_rw refine rw exact


by_cases by_cases rw by_cases rw let rw refine simp_rw exact have refine rw rwa hc'.collinear_insert_iff_of_ne exact


unfold rw rcases unfold rw rw use rw simp


simp angle_smul_right_of_pos, rw apply simpa


rw rcases refine have rintro rw simp have rintro rw simp replace replace refine rw smul_smul,


refine rw rintro refine rw rw smul_smul, convert field rw exact


rw rcases have rintro simp replace refine rw


constructor rw rintro rcases refine rw refine rw exact rw rintro exact exact


refine replace by_cases exact by_cases exact rw rcases exact exact exact rcases simpa simpa rw rcases rw exact rw exact rw exact


unfold rw nth_rw rw rcases rcases simp field_simp


have rw refine rcases exact exact rw div_pow, nth_rw rw


rw by_cases have rw mul_self_eq_zero] simp exact


by_cases rw rw rw refine rcases exact exact


rw by_cases simp by_cases simp rw have simp intro rw apply rcases have rw real_inner_smul_left, real_inner_self_eq_norm_sq, ring field_simp


rw by_cases simp rw hx, norm_num have rw constructor rw simp rw simp rw field_simp rw have rw sq, real_inner_comm ring rw simp


rcases linarith suffices have rwa have nth_rw simp real_inner_comm norm_num rw rw have by_cases simp by_cases simp exact have grw apply ring


rw obtain rcases simp simp_all simp_all rw by_cases simpa have rw simpa


constructor by_cases tauto right by_cases have rw obtain lift exact have by_cases subst rw obtain lift rw simp norm_cast grind by_cases subst rw obtain lift exact have grind have grind have grind have have angle_expression_of_angle_eq_angle_sum simp have have simp exact exact obtain grind exact


conv_lhs rw dist_eq_norm_vsub have have rw ring rw sub_eq_add_neg, simp


have inner_vsub_vsub_of_dist_eq_of_dist_eq have inner_vsub_vsub_of_dist_eq_of_dist_eq let have refine intro fin_cases intro fin_cases exact rw exact have refine rw intro fin_cases exact exact rw have intro have have classical rw simp rw rcases rw rcases exact rcases simp vsub_eq_zero_iff_eq, rw subst have have rw simp rw rcases


cases induction zero exfalso have lia succ rcases rw obtain haveI use simp constructor simp_rw exact rintro rintro replace rw have let classical have rw rw hn] simp simp haveI have replace have change rw congr simp rw refine convert change rw congr simp


have dist intro rw vsub_vadd_eq_vsub_sub, one_smul fin_cases rw obtain exact hr


change have obtain use refine exact rw obtain exact


classical have ext refine obtain exact exact change rw simp_rw rintro injection


rw symm refine intro cases have simp rfl


have have grind have simp have have exact


rw simp_rw rw real_inner_self_eq_norm_mul_norm, simp add_sub_cancel] have apply_fun rw simp convert ring


rw refine rw simp exact rintro refine simp rw exact


have have rwa replace rwa replace rwa convert simp


have rw intro refine by_contra obtain rw revert apply nth_rw grw rw exact add_pos_of_pos_of_nonneg


constructor simp_rw exact h.sum_excenterWeights_eq_one rintro rw


intro rw obtain simp have have grw simp lia obtain exact rw exact h.excenterWeights_ne_zero


refine have simp simp_rw have have rcases simp simp left ext replace split_ifs simp_rw simp simp right ext replace split_ifs rcases rfl simp


intro dsimp rw rcases simpa have obtain rw replace simp_all


rw h.signedInfDist_excenter, simp rcases simp simp simp


refine rintro obtain have intro rw exact simp_rw have simp_rw intro replace rw rw have simp_rw ext rw simp subst exact rintro refine rw simp


simp_rw refine rintro have refine apply refine grind rintro replace rcases refine simp


intro by_contra by_cases subst rw apply convert suffices have rw exact have rw exact rw exact obtain have simp convert simp rw refine rw exact rw exact


have refine continuousOn_of_forall_continuousAt intro rw rw by_cases subst rw exact refine simp h.exradius_pos, rw rcases exact exact rw exact refine convert simp


have rw s.signedInfDist_affineCombination rw convert rw exact


intro rw affineCombination_eq_touchpoint_iff have obtain have simp rw apply_fun rw have rw simp rw by_cases


Affine.Triangle.excenterExists

have rcases exact rw exact exact rw exact


rcases simp have simp field_simp simp field


rcases rw rcases rw positivity rcases rw have rw rw rw convert


rcases have simp simp_rw have have exact refine this.congr_fderiv have simp mul_pow] simp div_eq_mul_inv,


rw simp field_simp have rw rw rw simp invOf_eq_inv]


have subst simp_rw congr convert ext simp simp simp_rw congr by_cases


rw have intro rw exact have rw exact rw have rw ext simp_rw constructor rintro use rintro use rw have let obtain have exact exact


obtain clear decide rw rw rw have intro obtain all_goals exact


symm rw rw use have refine refine have rw exact mem_affineSpan rw t₂.independent.finrank_vectorSpan rw use have rw have refine have rw exact


by_cases left rcases obtain clear decide have intro replace exact rcases rcases have intro rw exact exact right have rw classical refine rw


rcases use reflection_mem_of_le_of_mem intro rcases have repeat convert rw exact rw dist_reflection_eq_of_mem exact use intro rw rcases exact


have rcases have rw refine ext_of_direction_eq have refine rw t.independent.finrank_vectorSpan


rcases use intro have rw rcases rw have rw exact rw affineSpan_of_orthocentricSystem exact


rcases rw rcases obtain clear decide suffices have have rw simp_rw rw exact rw convert exact


rw by_cases obtain have have have obtain rw simp have rw


obtain have have have rw have have nlinarith simpa


constructor exact intro have rw symm exact


constructor rintro exact rintro have suffices rw simp exact


rw constructor intro rw vsub_sub_vsub_cancel_right, smul_eq_zero] norm_num exact intro rw


rw simp map_direction, rw intro rw obtain rw


rw rw abs_norm] by_cases simp rw rw simp


rw rw by_cases simp rw rw simp refine simp use constructor positivity rw rw simp


have by_contra have grind have have grind have have have have have have have grind have grind have grind have have rw rw rw mul_comm] have have rw rw rw mul_comm] apply apply exact


have have rw set have rw apply simp simp have have have rw rw field_simp rw have field_simp rw have have rw rw rw use refine intro fin_cases try all_goals


rw rcases have have have have rw field_simp have field_simp rw by_cases rw rcases have rw simp_rw have rw simp_rw rw apply repeat


rcases rw refine simp have rintro replace rw exact field


rw intro rw rcases rw have intro have exact rcases have choose have intro rw exact have have rw simpa have intro have rw exact simp_rw have have intro have simpa have exact


by_cases refine rw rw refine rwa rcases refine rwa rw rintro rw refine simpa rw nth_rw rw smul_ne_zero_iff, rintro refine simpa


refine have simp have simp rcases have rw real_inner_smul_left, rcases nth_rw rw rcases rw rw exact rw exact simp rw exact rcases


let have have have have have rw iterate rw rw refine rw rcases rw rw use match_scalars ring


apply apply exact mul_dist_eq_mul_dist_of_cospherical


have have rw h_tangent.dist_sq_eq_of_mem ring


have have have have rw rw all_goals have rw rwa all_goals have have simp dist_sq_mul_dist_add_dist_sq_mul_dist


refine by_cases simp rwa div_eq_zero_iff, rw


refine rcases rwa rwa rw rcases rw subst by_cases simp rw rw rw rcases


by_cases have simp rw convert convert ring


obtain let have let have suffices refine simp_rw rw simp refine simp simp


have have rw vsub_sub_vsub_cancel_right] simpa


refine rintro rw exact rintro refine rw simp


have have rw exact eq_of_direction_eq_of_nonempty_of_le


obtain refine convert rw rw have refine rw exact


rcases have rw obtain rcases rw rw rw exact obtain refine rw congr rcases simp_all rw rcases simp_all have simp_rw right_eq_mul₀ rcases simp_all right convert rw rw simp


ext rw rintro by_cases exact refine rintro exact


refine rcases exact rintro refine by_cases simp exact refine simp abs_of_nonneg field simp rw field simp refine positivity rw linarith


refine rcases exact rintro by_cases rw have simp rw have refine rw exact have intro rw exact refine simp abs_neg, field simp field rw simp rw linarith rw simp


obtain simp obtain simp obtain simp have simp rw simp have field_simp ring_nf


rcases simp rw mul_comm have simp rw simp ring


rcases simp rw add_comm have simp simp ring_nf


rcases simp have rw obtain simp have replace contrapose grw linear_combination have replace by_contra grw have grw rw obtain obtain have cases linarith contradiction obtain simpa


have rw rcases rw o.angle_eq_iff_oangle_eq_of_sign_eq angle_comm refine rw exact rw simp


rw unfold rw neg_vsub_eq_vsub_rev, vsub_sub_vsub_cancel_right exact


by_cases by_cases have have have replace have rw rw have linarith


by_cases simp let have have simp calc dist rw field


have calc dist simp ring by_cases have rw have have exact


have rw have have apply simp intro by_cases have exact by_contra have linarith by_contra have by_contra have linarith rw have have by_contra have linarith have rw have rw rw exact linarith


constructor exact intro by_contra rcases have apply rw linarith linarith rw have linarith


by_cases subst by_cases subst simp simp_all linarith rcases linarith


obtain simpa refine contrapose rw wlog simp replace induction zero succ rw rw exact subst simp let mul_mem norm_cast simpa one_mem inv_mem norm_cast have have rw rw simpa exact


set let have have have norm_cast simpa have calc rw rw simp rintro have have have simp_all gcongr simp forall_apply_eq_imp_iff₂, rintro exact


classical set rw refine calc gcongr simp rintro refine simp


have constructor have rw exact intro have apply exact


ContMDiffWithinAt.prod

classical induction empty insert simp exact


rw obtain apply refine rintro rw exact refine rw


ChartedSpace.locPathConnectedSpace

refine let let have refine nth_rewrite apply exact refine refine exact exact


apply by_cases refine exact simp true_and] exact exact


ChartedSpace.discreteTopology

apply have isOpen_inter_preimage convert refine simp intro exact


set have have have rw replace have filter_upwards have rw exact have rw exact convert exact simpa


set suffices have refine replace replace exact have set have have have exact


intro let let let have let have let mfderivWithin have s have s exact exact


rcases have apply apply simp have haveI this.mdifferentiableAt have rw simp exact exact exact exact simp rw rw congr refine simp simp simp


even functorial the is a to product rintro have simp apply exact exact rw simp refine exact the have apply filter_upwards simp let have apply apply simp have simp rw let have apply apply simp have exact simp change rw rw simp the have apply filter_upwards simp let have apply apply simp have simp rw let have apply apply simp have exact simp change rw rw simp


rw constructor apply apply exact apply convert simp


apply intro let let obtain obtain hxf let refine simp rw simp have have have have refine dsimp mfld_set_tac have intro simp have have have calc f refine mfld_set_tac


constructor intro refine intro let have let let obtain refine obtain e e.source have have have rw rw exact dsimp apply simp have rw dsimp have rw have have apply refine rw rw have intro exact rw rwa refine mfld_set_tac refine rw rintro refine let let rintro refine intro simp have refine simp mfld_set_tac have have rw convert simp dsimp intro simp have refine simp mfld_set_tac have have rw convert simp dsimp mfld_set_tac simp simp


ContMDiffWithinAt.comp

rw refine set set have rw have simp filter_upwards inter_mem_nhdsWithin rintro simp refine filter_upwards rintro simp exact filter_upwards rintro simp simp


ContMDiff.piecewise

intro by_cases apply filter_upwards rw apply by_cases have apply filter_upwards simp apply filter_upwards rw contrapose simpa


haveI rw use intro apply intro simp rw rw apply exact letI extChartAt_target_subset_range have rw have rw exact


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


rw refine refine simp simp simp rw refine exact exact


ContMDiff.inl

intro rw refine apply simp congr apply set have rw exact filter_upwards simp


ContMDiff.sumElim

intro rw refine cases inl have let rw simpa apply simp filter_upwards congr simp congr inr have let rw simpa apply simp filter_upwards congr simp congr


nontriviality inhabit let have rw rw apply intro rw use


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


refine rw rw rw set refine rw map_extChartAt_nhdsWithin exact


constructor intro refine simp let have specialize have have convert simp mfld_set_tac rintro refine refine dsimp convert mfld_set_tac


rw refine intro rw apply apply simp exact intro simp exact


simp and_congr_right_iff] intro constructor refine have convert simp exact


ContMDiffWithinAt.contMDiffOn'

have have ω rcases rcases rw exact rcases rcases rw exact


refine rw rintro filter_upwards apply exact


have have have rw rw have have rw rw inv_mul_cancel_left exact


have ext simp have rw congr simp exact exact


multiplication composition is smooth and which have have rw norm_num let have let have let have let have contMDiff_equivTangentBundleProd_symm let have apply rw exact let convert simp simp rw simp


ext rw mpullback_mulInvariantVectorField, exact exact exact exact


refine set let have have simp exact refine have have have have calc exact


have rw exact have apply exact refine exact


intro have obtain rw rw let have simp toFun_eq_coe, preimage_univ, exact exact


rewrite refine h.codChart_mem_maximalAtlas, use apply intro simp


apply intro suffices trans congr apply simp_all exact


by_cases rw use exact inhabit let use exact


intro rw refine suffices split_ifs simp simp modelWithCornersEuclideanHalfSpace, rw have apply simpa have apply simpa filter_upwards rw linarith simp simp simp modelWithCornersEuclideanHalfSpace, rw have apply simpa have apply simpa filter_upwards rw linarith


intro rw refine suffices split_ifs have dsimp apply apply filter_upwards ext suffices rw simp have dsimp apply apply filter_upwards ext suffices rw simp


refine have rw convert ext simp have exact


by_cases rw rfl rwa rw simp exact exact simp have rw congr convert


have mfderivWithin mfderivWithin congr apply intro simp rw simp rw rfl


ext rcases have rw apply have rw apply apply simpa rintro


instIsManifoldIcc

have apply intro simp rcases exact apply rintro simp lt_sub_iff_add_lt, rw ext rw simp update_self, abel apply rintro simp max_eq_left rw ext rw simp mfld_simps] abel exact


have suffices simp stereoInvFunAux_apply, suffices simpa rw simp ring


have convert simp have convert have convert ext simp convert ext simp


have have refine intro nlinarith have refine exact exact


refine rw have have rw linarith positivity simpa simpa


ext simp set set have rw rfl have have have convert simp simp exact sq have have linarith rw simp match_scalars field_simp linear_combination field_simp linear_combination


simp have have have rw match_scalars simp ring


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


rw simp let suffices convert apply have convert simp have refine rw simpa


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


rw constructor intro rw obtain refine intro exact


IsMIntegralCurveOn.hasDerivWithinAt

replace rw apply rw intro rw mfderiv_chartAt_eq_tangentCoordChange rfl


apply eventually_mem_nhds_iff.mpr hγ rintro have rw rw apply rw intro rw mfderiv_chartAt_eq_tangentCoordChange rfl


rw obtain obtain hv.contDiffAt t₀ simp_rw have have rw have hcont rw obtain refine isMIntegralCurveAt_iff.mpr intro let have fderivWithin rw have have have have apply refine simp change rw tangentCoordChange_comp apply apply mem_nhds_iff.mpr isOpen_interior, rw exact


set tangentCoordChange hv rw obtain obtain have have eventually_mem_nhds_iff.mpr have mem_preimage.mp have apply apply rintro rw apply congr apply rw exact have apply intro rw suffices exact


rw refine intro rw push_neg obtain refine rw exact by_cases rw exact rw exact


rw obtain refine convert ext rw abs_mul,


intro have rw exact apply exact rw refine have rw exact


intro by_cases rw apply hγ rw refine rw exact have rw rw apply hγ rw refine rw exact


let suffices rw rw intro obtain exact intro set obtain rw rw obtain obtain rw set have simp obtain rw set have simp simp_rw simp_rw have le_csSup set have rw suffices apply exact


by_cases letI have simp simp intro convert rw rfl rw rfl simp


by_cases letI letI rw apply apply apply simp


apply intro change rw simp constructor refine exact refine exact


constructor intro rw simp_all intro have simp_all


obtain obtain constructor have rw rw exact have rw rw exact


IsManifold.empty

apply intro set have calc have calc t apply


unfold simp rw tendsto_map'_iff] rw filter_upwards rw exact hmaps hz.1


rw conv congr skip rw refine refine simp_rw


intro rw intro have inter_mem have apply obtain mem_closure_iff_nhds.1 refine have exact


simp_rw intro obtain have apply refine apply have simp apply simp exact have apply exact exact


rcases obtain have obtain have apply rw apply simp exact


ext have rw constructor replace rw exact change rw obtain rw exact


by_contra set rw constructor rw rw have exact


choose choose have eqOn_of_leftInvOn_of_rightInvOn exact invFun left_inv right_inv contMDiff_toFun contMDiff_invFun intro let obtain apply have exact


have have e'.symm.open_source.mem_nhds constructor intro rw have rw refine exact simp_rw exact


refine have rw refine refine simp_rw rw refine simp_rw


rw swap simp_rw rw refine refine refine simp_rw simp_rw e.left_inv refine simp rw


rw and_iff_right_iff_imp] intro have have exact


refine refine hG.congr_nhdsWithin simp_rw rw exact


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


obtain obtain refine simpa exact exact trans apply exact exact rw exact


IsOpen.liftSourceTargetPropertyAt

rw intro refine exact hx.codChart_mem_maximalAtlas,


use simp simp exact apply simp exact exact


rw refine have simp have have this.1 have simp rw simpa apply


rw refine have have have this.1 have simp rw simpa apply


have mfderiv_comp rw have rw apply have exact


constructor intro simp exact intro simp exact


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


have have have have mfderiv mfderivWithin rw exact rw exact exact intro apply exact exact exact rw apply filter_upwards simp simp


refine rw rw rw set refine rw nhdsWithin_inter_of_mem] exact


constructor intro refine simp let have specialize have have convert simp mfld_set_tac rintro refine refine dsimp convert mfld_set_tac


simp intro constructor refine have convert simp exact


contrapose rw contrapose rcases have exact


have refine rcases rw refine have nhdsWithin_mono rw apply rintro simp rcases left have exact exact apply simp_rw


refine apply have extChartAt_preimage_mem_nhdsWithin apply simp simp


by_cases unfold simp apply simp filter_upwards simp simp unfold rw rwa


HasMFDerivWithinAt.comp

refine have have extChartAt_preimage_mem_nhdsWithin unfold rw have rw apply intro simp have simp apply simp


refine have apply mfld_set_tac apply simp


refine have apply mfld_set_tac filter_upwards rw exact apply exact


HasMFDerivWithinAt.prodMap

refine have simp rw intro refine simp_all use simp_all use rw apply apply exacts


rw congr have rw simp rfl exact exact have rw simp rfl exact exact


cases inl let have intro simp dsimp rw exact apply rw refine exact inr let have intro simp dsimp rw exact apply rw refine exact


have rw exact filter_upwards rcases simp


HasMFDerivWithinAt.prod

classical induction empty insert rw rw convert simp refine rw simp


rw congr have simp_all simp rw simp apply apply simpa


have refine simp mfld_set_tac rintro exact


suffices let have ext simp rfl simp exact rcases dsimp rintro simp simp constructor rw convert apply exact rcases exact


haveI haveI have rcases choose rcases exists_subset_iUnion_closed_subset choose refine simpa refine exact simpa


have rcases set refine suffices refine exact


haveI haveI have rcases exact intro rcases exact


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


rcases have g.support intro apply exact choose have have refine refine apply have obtain refine apply rw have simp apply apply apply rintro simpa apply intro by_cases suffices rw contrapose simp exact have rw simp apply intro apply exact intro apply


satisfies rcases rcases have intro by_cases have linarith have classical apply rw contrapose exact linarith refine exact f_diff.div₀ refine apply simpa have simp intro simp


refine simp intro let have rw simp conv_lhs exact let have apply riemannianEDist_le_pathELength rw exact apply rw simp exact


rcases lift simp refine filter_upwards simp exact_mod_cast


rcases refine have filter_upwards rw have convert


rcases refine have rw have filter_upwards have simp convert


rcases have apply exact filter_upwards apply have rwa exact simp


simp apply have congr apply filter_upwards


rw simp_rw have measurePreserving_subtype_coe rw congr ext have congr


rcases simp have simp have rw apply have rw apply apply rw exact exact rw exact rw simp have simp rfl rw have simp


let have apply rw exact rw simp let have rw apply simp let have apply rw have apply simp rfl rw simp simpa apply


reparameterize locally rcases rcases rcases let have simp apply simpa linarith have have simp rw have refine rw apply rw fun_prop intro exact convert rw apply apply apply intro dsimp gcongr simpa simp apply fun_prop rw apply filter_upwards filter_upwards


suffices intro apply rcases let have apply simp fun_prop have apply rw exact exact exact apply convert ext simp


apply rcases rcases rcases let have apply apply exact simp simp exact apply rw gcongr convert apply intro simp convert apply intro simp


constructor rintro simpa let rintro obtain have convert exact have rw obtain let have have convert ext change rw clear_value subst have obtain convert exact have hV₀f let refine rw convert apply ext apply exact rw convert apply ext apply exact intro exact


have let suffices rcases exact have apply intro by_cases refine exact have have by_cases simpa simpa exact


constructor intro rw rintro refine convert ext intro constructor intro rw refine apply exact


simp rw intro simp_rw chartedSpaceSelf_prod] refine have refine simp_rw rw exact simp


intro unfold rw apply filter_upwards congr_arg


have rw refine rintro refine have simp_all exact


Bundle.TotalSpace.isManifold

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


rw choose have intro rw exact have intro have simpa have intro have rw exact have apply intro exact rintro exact refine rintro refine intro rw


classical rw choose have refine rw exact have ext have have exact have ext rw refine rintro exact have rw apply let let have have intro refine exact have apply intro refine refine intro rw have apply intro refine refine intro rw refine rw rw congrm rw apply


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


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


apply trivial choose have intro rw use simpa rw


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


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


rw set refine apply exact intro apply apply


classical induction empty insert simp apply exact


obtain let have have apply apply rw refine by_contra have refine simp use simpa exact rw refine by_contra have refine simp use simpa exact


apply rw choose have intro rw use simpa exact


have apply intro refine refine hx).mono_of_mem_nhdsWithin exact


tangentBundleCore.isContMDiff

have refine rw refine rw simp_rw exact apply


ext ext exact ext apply exact simp_rw simp


simp rw simp simp have rw simp simp have rw simp


simp congr let let apply apply filter_upwards hy simp congr simp congr convert apply filter_upwards hy simp congr simp congr convert


filter_upwards hVy apply apply exact exact apply exact exact


simp congr rw apply apply exact exact exact exact exact


have simp congr apply exact rw mpullbackWithin_mlieBracketWithin apply rw filter_upwards self_mem_nhdsWithin] simp congr apply exact rw filter_upwards self_mem_nhdsWithin] simp congr apply exact


stating the let let let let have apply exact suffices s from have s have s apply apply apply apply rw exact isInvertible_equiv.comp apply have apply apply exact have apply apply exact filter_upwards simp rw simp rfl


that vector let let let let have apply exact suffices s from have s hf.mfderivWithin_const have s apply apply apply rw exact isInvertible_equiv.comp apply have apply apply exact have apply apply exact filter_upwards simp rw simp rfl


have have convert exact apply have simp_rw filter_upwards simp rw


have nhdsWithin_mono have apply filter_upwards simp simp


apply rw comp_embeddingPiTangent_mfderiv] exact


cases set letI letI set refine eEF.injective.comp rw eEF.mfderiv_eq] exact


obtain obtain let have replace rwa obtain use simp simpa


choose have intro simp tauto choose have intro apply rintro rw apply rw change rw obtain refine change rw exact


ext rintro rw exact rintro refine rw exact


ext simp not_exists] intro rw change exact


ext constructor rintro rw delta rw exact rintro simp rw rw exact


have dsimp rw rw haveI inferInstance apply apply apply apply apply


fapply ext simp_rw congr exact exact isColimitCoforkMapOfIsColimit suffices delta rw dsimp rw erw apply refine rw


constructor rintro rcases rw let have imageBasicOpen_image_preimage have hV.symm have have have rw apply rw erw convert


refine have refine rcases set change suffices apply rw erw apply change infer_instance


have intro have induction op cases dsimp congr exact convert have apply let invFun exact


refine simpa induction simp app_invApp_assoc, ofRestrict_base, rw congr


refine change simp induction op change simp_rw erw erw have dsimp rw replace erw simp


refine change simp change simp_rw erw erw trans congr simp


haveI have delta rw change infer_instance apply


rw have rw have dsimp rw rw infer_instance


rw have rw rw have rw cases rw simp_rw exact


ext apply rintro replace eq simp_rw rw change cases rw exact


obtain let have colimit.ι rw infer_instance


refine use intro have rw rw rw dsimp infer_instance exact


change apply dsimp apply exact dsimp infer_instance


have dsimp have rw rw ext constructor rintro rintro rw show infer_instance


rcases rcases dsimp subst dsimp erw subst rfl


haveI constructor intro ext1 have simp rw exact ext have ext1 exact haveI have rw cancel_epi] have simp simp simpa


have dsimp rw simp_rw erw convert erw rfl


fconstructor delta dsimp congr have rw replace replace replace dsimp rw swap refine rw refine refine refine intro rw intro rw rw simp_rw dsimp rw dsimp simp_rw rw simp_rw rintro replace change rw subst use change congr rw


ext1 dsimp rw show rw refine dsimp rw refine rw swap exact change rw simp rw infer_instance


constructor delta simp_rw rw erw simp_rw erw simp_rw dsimp rw congr


rcases refine rw congr dsimp rw change congr exact exact


fconstructor congr simp refine rintro convert delta apply_fun exact have dsimp rw refine rw infer_instance delta rw change dsimp rw erw simp rfl rw simp rw infer_instance


rw simp_rw rw erw rw change rw simp_rw rw erw erw iterate rw erw convert rw apply change rw apply erw infer_instance have infer_instance


ext induction op rcases rw congr simp_rw apply simp_rw rw apply


refine limit.lift π naturality refine dsimp rw simp dsimp rw have simp replace have rw simp


refine refine fapply intro refine simp refine erw congr exact intro change rw erw rw erw rfl


obtain obtain obtain congr ext refine erw simp


constructor intro obtain refine rw replace congr


constructor intro rw obtain rw simpa refine rw congr


refine induction op let erw simp_rw erw erw exact


dsimp refine induction op dsimp simp assoc, tauto


obtain refine intro obtain have by_contra have refine exact exact have contradiction simp


have rcases simp lift rw exact simp exact have rcases rcases exact classical by_contra simp rcases obtain rcases exact refine calc x


rw constructor suffices rintro exact rcases exact exact exact


suffices have not_isOfFinAddOrder_of_isAddTorsionFree rw simpa


constructor have have rw obtain have simp obtain have rw rw rcases wlog convert simp rwa rw rcases refine simp intro simp rintro rw contrapose rw exact


by_cases obtain exact refine intro specialize obtain contrapose refine refine simp simpa


suffices rcases simpa simp exact intro rw obtain lia


rw refine refine intros simp recZeroCoe_coe, map_eq_zero, rw refine intros simp split_ifs


suffices rw refine try simp constructor intro replace rw by_cases replace rw intro obtain wlog refine simp simp obtain obtain exact exfalso obtain obtain refine simp rintro have exact


suffices rw refine exact intro rcases simp rcases simp simp exact intros rw simp rw refine intro simp simp exact simp simp intro simp


have rw refine intro rcases simp simp refine simp intro refine contrapose simp simp intro simp intro refine simp simp intro refine simp


classical cases rw simp congr swap convert simp calc rw rw refine rintro simp rw exact


simp_rw commutatorElement_def] intro trans x x⁻¹ simp rw simp


let change suffices rw exact refine simp_rw rcases exact


simp_rw constructor intro exact rintro rw exact


apply rw rintro exact rw constructor rw apply simp


apply rintro exact exact rfl⟩, hg.choose_spec.choose_spec⟩


constructor intro rw rw rintro rw simp simp apply intro apply rintro intro rw apply rw exact


rw let apply rw simp have rw exact simp simp


classical apply rw intro rw apply rw intro rintro by_cases subst simpa simp


commuting rw div_mul_cancel₀, refine exact exact exact


conjugacy rw div_mul_cancel₀, apply show exact exact exact


by_cases rw apply by_cases rw rcases rw simp norm_num rw have rw grind positivity


refine obtain exact have h.1 exact rintro exact


classical refine by_cases exact refine exact


let have rw obtain refine have rw simp rw refine


let have rw obtain refine have rw simp have rw refine


rw constructor intro rw inv_mul_cancel_right, exact intro apply rw rw rw


rw constructor intro rw mul_inv_cancel_left, exact intro apply rw rw rw


Subgroup.IsComplement'.isCompl

refine let let codisjoint_iff_le_sup.mpr obtain exact


refine obtain have refine rintro specialize refine rwa


apply intro simp have intro induction of intro apply rwa refl intro rw exact symm trans exact mul rename_i intro rw rw exact exact


Con.liftOnUnits

refine f refine rw rintro refine rw rintro exact


rintro induction one of simp exact mul simp exact


rintro by_cases simp simp_all exfalso simp rw exact exfalso simp rw exact have simpa rcases congr exact


Monoid.CoprodI.Word.consRecOn

rcases induction nil cons ih refine rw simp intro exact exact


simp induction empty cons simp split_ifs subst by_cases by_cases subst simp


simp induction empty cons by_cases subst simp


rw by_cases subst simp by_cases simp simp intro split_ifs rcases simp constructor rintro exact rintro simp subst rfl simp not_exists] exact revert rw cases simp simp rcases


induction one intro rw of intros rw mul intro rw


suffices rcases refine ext rw obtain induction nil cons rw rcases refine simp rw specialize obtain obtain refine simpa


unfold induction singleton append specialize simp congr


obtain have rw exact let have intro apply simp


classical rcases obtain exact obtain by_cases subst subst exact subst change exact subst change have lift_word_prod_nontrivial_of_head_card intro apply simpa change change exact


have ext simp rw clear refine change let let let apply show exact show intro simp apply exact exact exact exact change rintro refine intro change simp change have rintro apply simp clear simp rcases have calc a smul_set_mono clear induction base succ calc a have apply simpa calc a smul_set_mono clear induction base pred calc a show inhabit right use simp rw exact


rcases induction one mul_of cases inl inr


have have refine ext suffices constructor rintro exact intro exact


have fintypeOfIndexNeZero rw rw exact suffices intro specialize specialize rw rw exact rw constructor rwa simp


classical have induction ind have simpa replace intro simp_rw have simpa rw refine rwa simpa let let let have have exact have replace rw cases inl have have have exact inr have exact have not_isEmpty_iff.mp rw exact by_cases rw exact have hn refine rw exact have exact


classical have by_contra rw exact by_cases rw exact have exact


classical let have have iInf₂_le choose exists_leftTransversal_of_FiniteIndex let let let have rw rw apply by_cases simp by_cases simp have have have replace rw by_contra obtain by_cases have have rw refine by_cases rw mul_inv_cancel_right₀ simpa rw simpa refine rw refine rw refine by_cases simp rw refine rw exact rw intro have rw have rw suffices have refine simpa simpa have have rw exact hdisjoint


by_contra apply cases inl inr have have cases inl inr apply rw


rw simp_rw constructor intro apply rw exact intro rw rw exact


let have induction one mul_left rw exact


let have induction one mul_right rw exact


induction zero succ have apply by_cases simp simp rw apply rw simp simp simp rw apply rw simp


induction zero succ rw by_cases have have simp have have simp


simp_rw simp_rw generalize clear push_cast rcases rw repeat rw simp have rw have rw rw repeat norm_num rw simp


induction nil cons dsimp rw simp cons.injEq, group


induction nil cons dsimp rcases simp simp simp


induction nil cons dsimp rcases simp rw rw rw rw simp


induction nil cons dsimp rcases use group exact


simp have calc apply intro exact rw nth_rw rw exact


apply intro show replace rw apply rw set set have have rw exact have calc π have calc ω.length grind


induction zero simp wordProd_nil, simp succ hk simp alternatingWord_succ rw simp


constructor intro rcases have rw rintro exact


apply simpa by_contra have rw have contradiction


constructor intro rcases rcases exact rintro exact


rcases right have simp lia left have simp lia


induction refl suffices unfold rw lia have rw have rw calc ℓ step contrapose rw apply simpa


obtain rw congr simpa rw have rw congr simpa simp


DivisibleHull.archimedeanClassOrderIso

apply ext induction mk induction mk suffices simpa simp_rw ext induction mk simp


ext rw constructor rintro rwa rintro exact


ext simp constructor rintro refine simp rintro refine simp


rcases simp constructor intro rw rw intro by_contra rw have have apply simp_rw exact exact


haveI rcases refine have rw apply rw rw obtain suffices exact hp.one_lt.not_ge obtain obtain refine rw apply rwa rw exact


by_cases exact exact exact exact h.orderOf_mul_pow_eq_lcm


refine rw exact rw intro by_cases simp rw obtain simpa


refine by_contra obtain exact lift have refine rw obtain exact suffices intro rw exact rw intro apply rw exact


have have have rwa obtain use apply refine rw by_contra replace simp set obtain suffices rw exact have have rw obtain have rw apply nth_rw have rw simp rw exact rw mul_assoc, exact exact


rw by_cases rw rw rw simp_rw exact intro obtain rw simp_rw exact


classical rw push_neg peel obtain refine simpa


refine refine ext rw apply exact apply exact


refine refine ext1 rw exact rw exact exact exact


obtain refine rw exact f.toAddEquiv.trans


cases obtain rcases have exact haveI exact


obtain let obtain contrapose exact obtain use simpa


classical obtain let let have have have simpa exact let exact


Submonoid.FG.prod

classical obtain obtain refine push_cast simp


constructor rintro rw refine exact rintro refine rw exact rw exact


have rw refine ext constructor intro rw exact intro by_cases simp refine simp by_cases exact rcases rcases apply exact apply exact exact exact rw exact


refine simp intro simp intro simp intro simp


constructor generalize rintro rintro exact exact


apply generalize intro cases simp or_self, rcases simp


have rcases simp cases change apply have have rcases rw rwa


ext have trans simp_rw simp_rw induction


n have refine rw refine rw exact rw refine rw exact


induction simp simp rw split exact rw exact


induction simp simp rw split nth_rw simp simp


induction simpa rw nth_rewrite have reduce apply repeat rw group rw apply exact rwa


rintro rw let let let change congr rw apply apply exact


FreeGroup.Orbit.duplicate

ext constructor rintro set have simp_rw exact a have have refine simp_rw inv_smul_smul] exact rintro exact mul_smul inv_smul_smul exact


FreeGroup.reduce.red

induction nil cons dsimp revert generalize intro cases nil cons dsimp split_ifs cases cases cases dsimp subst_vars apply exact exact


have have rw simp constructor simpa simpa


have have exact mk_goursatFst_eq_iff_mk_goursatSnd_eq


Subgroup.goursat

let let let let let have simp simp exact have simp simp exact have have obtain refine rw simp rw ext constructor intro simpa exists_and_right, simp exists_and_right, rintro simp rwa convert ext simp_rw


rw ext simp_rw refine rcases simp refine simpa rcases simp simp refine exact simp exact


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


constructor intro convert simp intro exact


rw intro obtain simp suffices simp apply intro exact suffices rw simp


rw intro obtain simp suffices simp apply intro exact suffices rw


MulAction.IsBlock.isBlockSystem

refine rintro simp intro apply simpa intro obtain obtain use simp forall_apply_eq_imp_iff, exact


simp ext simp constructor rintro use simp rw rintro use simp simp


ext constructor rintro simp rw exact intro obtain exact


ext constructor intro obtain simp_rw exact intro rw apply


MulAction.BlockMem.instNontrivial

rw use intro rw simp obtain apply rw apply


rcases simp have rw interval_cases rw exact rw rw


suffices rw cases inl inr cases inl inr rw rw exact hB are


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


classical rcases rw simp calc card congr exact


refine rcases exact rcases dsimp rw subst exact


letI set ext constructor rintro obtain rw exact intro rw obtain rw refine rw convert simp


letI set refine simp intro rw rintro obtain exact


refine rcases dsimp rw subst exact rcases exact


simp_rw convert rw suffices rw rw convert rw rw


rw ext rw by_cases rw constructor exact rwa


apply intro cases inl refine apply intro rw exact inr


have rw exact have rw exact have rw exact apply constructor apply intro have rw apply rwa rw obtain have rw rwa obtain apply rw obtain rw rw simp exact hyp


induction h have have intro rw simp have simp rcases have simp obtain suffices refine rw rw exact rw rw rw exact rcases have rw obtain obtain let have have apply rw apply exact have rw apply exact have suffices refine have apply apply rwa apply intro have apply rwa apply apply exact have rwa obtain obtain exists_mem_smul_and_notMem_smul let have simp simp have apply rw apply rw exact have rw apply refine suffices rw simpa apply exact rw have have suffices refine apply exact intro apply exact


have induction zero succ hrec suffices obtain have intro apply have rw rw apply norm_num have have rw refine rw apply rw rw exact suffices obtain use ext by_cases rw


have have suffices by_cases apply simp suffices rwa hα] let let map_smul have suffices unfold rw apply rw apply apply simp by_contra simp apply apply intro suffices conv_rhs simp exact simpa


obtain have intro simp suffices rw rintro obtain obtain use rw simp rw intro have simp_rw intro simpa let obtain exact


classical have rcases rw apply simp apply rw refine rw have apply rw exact obtain have apply rw apply suffices rw apply rw have apply convert rw simp


classical rcases rw apply rw apply rw simp apply suffices rw exact simp obtain apply suffices rw apply apply rw grind have apply convert rw apply ext simp


constructor intro rw apply intro rw constructor exact intro suffices rw suffices obtain rw simp exact


rcases rw rw apply rw constructor rw exact intro have apply rw aesop exact


constructor apply intro rw constructor exact intro have rw intro apply rw simp obtain obtain rw set let have ext constructor intro by_cases simp exact rw rintro simpa simpa rw apply apply simp rw apply rw rw exact


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


induction zero succ rcases rw apply refine


refine intro rw constructor exact intro let let simp intro suffices obtain rwa obtain simpa let x simp exact map_smul rw apply simp rintro obtain suffices simp intro apply rw exact constructor rintro suffices simpa rintro obtain suffices simp exact


refine obtain have rw convert simp use ext simp rw obtain obtain obtain use ext simp simp simp rcases simp simp exact


induction zero rw simp succ hrec have rw apply rw rw exact have rw exact obtain let have rw simp rw congr have have rw rw simp have rw suffices convert rw apply intro obtain apply simp suffices rw exact convert all_goals


Equiv.Perm.isMultiplyPretransitive

rw classical intro have have rw nth_rewrite rw simp rw obtain let set have constructor intro by_cases obtain by_cases obtain simp rw simp rw rw rw exfalso have rw exact rw apply exact by_cases obtain simp rw rw rw exfalso have rw exact rw apply exact simp rw rw rw rwa intro by_cases obtain use simp rw use simp rw simp set have rw simp rintro apply rw exact use ext simp


have simp let rw intro let let obtain suffices have apply rw exact have have rcases exact obtain rcases suffices rw exact apply rw rw apply rw ext obtain specialize simp simp


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


rcases rw rw exact apply obtain rw have rw rw rw refine


rcases exact rcases replace have have exact suffices apply letI apply rwa


constructor intro apply intro rcases left right intro rintro simp cases inl inr


rcases exact have let replace rw simp exact exact


apply intro apply refine refine rw exact refine rw exact


refine contrapose have obtain obtain rw use contrapose simp rw simpa simp simp


Set.powersetCard.card

classical cases simp rcases simp rcases refine have exact simp


Set.powersetCard.nontrivial

classical have have have contrapose infer_instance


have have have have obtain rw rw apply rwa rw exact rwa


wlog have apply grind by_cases apply aesop suffices rw rw simp apply rcases infer_instance rcases rw exact have apply


have isPretransitive_alternatingGroup have obtain rw apply rw exact simp exact simpa


ext simp constructor rintro exact intro use constructor apply rw simp


constructor rintro simpa rintro rw use simp


constructor intro simpa rintro suffices intro rcases exact apply simpa


SubMulAction.ofFixingSubgroup.append

have let apply rw rintro apply simp simpa


rw obtain rw have rw exact rw rintro rw rcases obtain use rwa have have obtain use simp rwa rw intro rw exact


constructor rintro simp apply rwa intro exact


obtain have simp suffices simp use ext rcases simpa simpa


constructor apply intro apply intro obtain obtain use apply simp


let one_mem mul_mem inv_mem let lift have change rw exact


HNNExtension.NormalWord.consRecOn

rcases induction nil cons exact cons toList mem_set


by_cases simp induction ofGroup cons intro apply simp cases simpa simp simpa


rw split_ifs have unfold simp simp have unfold simp cases ofGroup cons clear simp mul_inv_rev] cases have apply dsimp conv_lhs rw simp dsimp conv_lhs simp


unfold have by_cases simp mul_inv_rev, cases simp simp rw rfl rw simp group_smul_head, congr conv_lhs simp_rw simp conv_lhs rfl


rw split_ifs cases simp cases simp rcases simp simp zpow_one, grind simp rcases simp zpow_one, erw simp simp zpow_one, erw simp


induction ofGroup cons ih rw rw simp ext rw simp


suffices w.head w'.prod w'.toList.map by_cases simp exact rcases exact intro rcases dsimp induction nil exact toList mem_set chain cons rcases clear refine rw simp have simp exists_eq_right, intro have rw have rw have have have rwa simp rw erw rw simp


rcases rcases rcases have subst refine simp intro rw rwa


have simp exact refine simp_rw refine refine exact refine obtain exact


by_cases by_cases simp rcases refine rwa


suffices rcases refine rw rw convert lia suffices rcases rcases exact exact by_contra simp_rw let have rintro have dsimp simpa have have simp


rcases rcases rcases conv_lhs congr simp let change rw


by_cases rw exact by_cases rw exact suffices convert exact have have rw have have rw exact apply rwa have hp.ne_one rw exact lt_of_lt_of_le hHp minFac_le_of_dvd


induction top step obtain rw exact grind


Subgroup.IsSubnormal.trans'

induction top step ih refine rw rw exact


Localization.r'

refine iseqv mul rintro use simp calc rintro use calc


simp constructor rintro exact rintro exact


let let refine simp_rw exact simp_rw exact


constructor intro obtain obtain use rw intro obtain use rw


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


constructor rintro exact rintro use rw exact


obtain refine dsimp by_cases rw subst rw exact apply convert rw


obtain refine dsimp by_cases have rw exact convert rw


rw constructor rintro refine dsimp rw exact rintro refine dsimp rw exact


rw constructor rintro use rw exact rintro exact


classical constructor intro exact intro rw exact


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


classical constructor intro rw exact intro rw exact


induction zero succ rw apply rintro exact


lowerCentralSeries.map

induction zero succ rintro refine closure_induction rintro apply exact


induction zero succ let calc comap comap


generalize rcases simp exact suffices apply apply apply rw exact apply calc n


obtain induction zero haveI exact succ ih have exact


induction zero succ calc lowerCentralSeries


let induction zero succ calc lowerCentralSeries


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


IsPGroup.isNilpotent

cases classical revert apply intro infer_instance intro have simp rw simp apply exact simp exact have exact


classical let have intro haveI exact exact


simp refine simpa simpa intro rwa intro have exact


apply rintro exact rw constructor rintro exact rintro exact


classical revert induction empty insert ih have simp have refine intro have exact intro rw have obtain intro simp rcases exact refine


change rw rw rw rw rw exact intro simp simp


letI apply rintro refine apply use simp refine rintro exact


letI apply rintro refine intro apply use simp refine rintro exact


classical apply rw intro have ext apply simp


cases letI rintro rw rintro dsimp rw rotate_left intro apply exact obtain obtain have rw exact have rw exact change rw obtain use rw symm rw intro exact


simp_rw split_ifs classical rw simp rw rintro exact


by_cases rw exact by_cases exact obtain exact


obtain suffices simp by_contra have obtain rw exact refine rw exact rw exact


have have apply exact refine rw refine by_cases exacts


let have rintro apply rw obtain exact suffices contrapose have have contrapose exact rwa


refine have have obtain obtain rw nth_rewrite have rcases


ZMod.minOrder

have classical have rw exact not_dvd_of_pos_of_lt refine le_minOrder_iff_forall_addSubgroup.2 rw haveI exact


simp have rcases have calc r₃ rcases symm use use simp constructor rw simp rw simp


cases cases cases rcases rcases rcases rw rw rw symm rw


refine obtain wlog exact use rw refine change rw simp_rw


rcases have rw exact rcases have rw exact convert rw refine


rcases have rwa have rw refine exact_mod_cast let have have let suffices have rwa intro grind


have refine suffices use rw intro obtain haveI obtain obtain exact


cases obtain rw rcases exact exact rw exact


have have rw classical calc card card_congr rw have refine rw obtain rw have contrapose simp exact ne_of_eq_of_ne


classical have rw have obtain exact obtain exact


rw intro obtain obtain rw have rcases simpa exact


by_cases rw rw exact by_cases rw rw exact have apply rw exact have obtain refine contrapose exact refine rw exact exact


suffices rw simp have rw simp conv_lhs simp


have have set have rw congr rw suffices rw simp rw rw simp congr exact


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


rcases rw rw simp conv_rhs obtain have rw zpow_add] exact


ext simp rcases simp rintro rw exact rw conv_lhs rw by_cases simp push_neg intro rw have rw exact simpa


simp ext simp by_cases rw have simp rw rw exact rw exact


constructor rintro rw apply obtain exact


classical set suffices simp simp_rw apply ext simp simp simp congr ext rw


split_ifs have rw rw contrapose obtain simp have rw obtain replace obtain rwa rw rw contrapose obtain mem_support_of_mem_noncommProd_support g.pairwise_commute_of_mem_zpowers exact


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


apply rw simp constructor rintro refine rw exact exact intro refine exact rintro simp set subtypePerm simp set use ext rw split_ifs rw rw rwa rw rwa


let have obtain obtain simp apply apply exact rw exact


split_ifs classical obtain convert simp_rw rw


split_ifs apply apply have positivity rw exact


let have have have intro induction zero succ convert simp_rw have intro induction zero simp convert succ by_cases rw exact by_cases rw exact rw exact have intro have rw have rw obtain rw exact have intro by_cases rw exact by_cases rw exact rw exact rw rintro rw exact


obtain obtain h1.exists_pow_eq rw refine obtain rwa


have have obtain contrapose exact contrapose refine simp_rw exact


refine exact rintro set suffices clear_value apply rintro rintro refine rw rw rw exact contrapose simp_rw by_cases rw simp


Equiv.Perm.IsCycle.extendDomain

rintro refine rw exact have rw rw simp exact


intro induction zero succ intro obtain exact have have simpa obtain refine rw swap_apply_of_ne_of_ne


have simp_rw exact obtain refine obtain exact


have refine intro obtain have obtain have intro exact rwa pow_apply_mem_support, refine simpa


rw constructor intro refine rw intro apply intro contrapose ext by_cases rw obtain apply rw simpa


classical cases constructor intro have rw rintro refine simp have rw rcases exact rwa intro obtain have refine rw exact


classical cases constructor intro obtain exact rintro by_cases rw contradiction rw obtain rw


classical cases constructor intro obtain exact rintro wlog exact suffices rw rw rw by_cases refine simp have simp rw contradiction


classical cases have refine rw exact obtain have rw refine rw exact


Equiv.Perm.IsCycle.isConj

refine isConj_of_support_equiv intro simp obtain simp


Equiv.Perm.IsCycleOn.subtypePerm

obtain haveI exact convert rw exact ne_of_apply_ne


obtain rw simpa classical have have simp implies_true, rw simp


classical obtain obtain refine rw sub_eq_iff_eq_add'.1 simp exact


classical obtain refine convert simp haveI haveI obtain refine of_not_not convert rw ext simp


ext simp refine obtain exact rintro exact


obtain refine simp_rw rwa classical rintro simp forall_exists_index, rintro rw rw exact


constructor intro have use obtain obtain use ext simp rw obtain simp rw simp exact rintro ext simp by_cases suffices rw simp intro have simp exact rw contrapose exact


simp_rw refine rw simp apply intro by_cases rw rw exact exact


constructor intro ext simp rw simp exact intro rw by_cases rw rw exact


set set have rw exact simp apply simp obtain simp rw simp id_eq] have constructor intro simp use intro simp rw by_cases simp simp exact


rw constructor rintro specialize rw lia intro by_cases on_goal exact all_goals


rcases norm_num induction nil cons use constructor rwa intro have obtain use simp


rw rw rw simp rw simp intro simp simp simpa simp


simp constructor rintro refine contrapose rw simp rintro simpa


by_cases rw simp have rw intro rw rw simp rw rcases simp rw simp rw simp intro have have rw rw refine rw rw intro obtain rw


rw obtain rw simp_rw rw simp_rw rw exact


have have refine rintro simp rw refine simp simp


obtain have rw rw simp rw simp simpa simpa


by_cases rw ext by_cases obtain rw pow_succ', rw exact rw simp


constructor have simp intro have exact intro simp use exact


cases obtain refine simp rintro simp refine contrapose suffices rw exact rw refine simpa


obtain refine rw subst intro refine simpa simpa rintro simpa


ext by_cases obtain rw simp rw contrapose obtain refine simp


by_cases rw simp rw split_ifs simp rcases rw simpa simpa


by_cases obtain rcases refine simp subst rw exact refine obtain rw rw


suffices exact intro classical cases constructor intro exact intro have intro rw rwa obtain rw obtain have have intro rw convert refine exact


classical refine by_cases obtain rw exact


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


rw constructor rintro contrapose rw simp intro refine intro rw rw split_ifs rfl rw contradiction


apply intro apply intro exact exact intro simp exact


constructor intro use rw exact rintro exact


suffices rw apply exact let let rw simp exact


suffices refine have rw exact intro simp apply intro simp apply simp_all


cases suffices classical let exact intro induction nil cons intro rw exact induction_disjoint


revert refine cycle_induction_on simp intro simp simp intro simp_rw rintro rw rw intro rcases exact refine by_cases rw simpa rw rw contradiction exact rw rw intro rcases exact refine by_cases rw simpa rw rw contradiction exact


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


constructor intro obtain constructor rw exact intro rw exact rintro have simp exact obtain use have intro apply rw exact rw rw apply rw apply intro rw rw grind simpa rw apply intro rw exact


by_cases rw simp refine rw refine rwa simp


induction base_one rw rw base_cycles have rw apply rwa induction_disjoint rw have obtain have refine rw have rw rw refine rw rwa exact


constructor intro obtain rw obtain rw refine rw exact rintro simp


let leftInverse_iff_comp.mpr have rw exact suffices suffices simp


have have calc p let have have have let rw have rw simp k replace let have obtain refine rw rw simp


haveI obtain have have have have rw exact


refine by_cases rw exact obtain by_cases rw rw obtain rw have cases


constructor intro intro symm apply apply apply rwa simpa rw simp rw rw simp simpa simp contrapose rcases exact suffices simp


constructor intro rw grind rw intro suffices exact


constructor intro rw intro apply simpa intro have have ext simp by_cases simp rcases rw simp rw simp suffices simp rw rw simpa


obtain obtain by_cases subst exact have rw exact mul_mem


set suffices simp apply exact exact simp intro apply apply apply intro rw simp intro simp apply intro simp


ext cases refine simp rw split_ifs simp rw


refine clear obtain rw induction zero succ rw rw exact


have have rw split_ifs have simpa rw rfl have have val_add_one_of_lt exact


rcases exact rw split_ifs rfl exact val_add_one_of_lt


cases rcases rcases have ext rw rw apply exact rw simpa rw rw apply rw apply apply simpa


by_cases have have subNat simp coe_toEmbedding, rw exact exact simp


have have have subNat simp coe_toEmbedding, refine split_ifs have eq_of_val_eq simpa have simpa rw simp rw lia


Fin.cycleIcc.trans

ext rcases simp rcases simp rcases simp split_ifs repeat simp split_ifs exact simp


simp_rw set have ext suffices refine rintro exact obtain exact exact nth_rw rw refine replace obtain simp simp


refine rw ext simp by_cases rw exact rwa


constructor classical rw intro rcases rintro obtain grind rintro rintro rintro obtain grind


classical have have exact let let let let rw use rw ext rw rw dsimp rw rw ofInjective_apply] dsimp rw


classical cases obtain obtain have have rw have have refine refine simp intro simp rw rcases rw rw simp apply_eq_iff_eq, have rw rw rwa rwa rwa rw rw simp have rw rw rwa rwa rwa


apply exact simp intro refine rw exact simp


rcases simp induction nil cons by_cases rw split_ifs simp simp simp replace simp


induction zero succ rcases simp rw specialize simpa simp simp rw intro rw simp


rcases simp have refine simpa rcases simp rw congr rw


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


have ext by_cases obtain rw simp rw simpa


refine rw have have rw simp push_neg exact simpa obtain have rw refine rw simp use apply rw intro rw induction zero refine congr simpa succ conv rw formPerm_apply_getElem congr rw apply


obtain rw cases exact rw rcases simp simpa


rcases simp rw constructor simp intro simp nonpos_iff_eq_zero, simp


rcases suffices simpa refine rintro simp exact suffices simpa refine rintro simp exact rcases simp simp simp


ext by_cases obtain simp have intro refine replace simpa simpa


suffices obtain rw intro by_cases exact rw obtain use rw contrapose rw rintro by_contra exact


rw ext simp_rw refine rintro simp use simp


suffices rw apply exact rintro by_cases aesop have aesop


classical obtain obtain intro rw have rw rw aesop


have intro rw obtain use rcases obtain exact rcases obtain use rw exact have rw have convert apply assumption rw aesop have rw refine exact have rw exact have apply rw exact cases inl inr rw apply simp_all


apply intro obtain exact intro obtain rw exact contrapose apply have rw rw


rw apply suffices apply rw exact suffices apply let let map_smul exact let let map_smul have rw infer_instance


suffices rcases rw apply have subst obtain have suffices apply exact suffices apply let let map_smul apply infer_instance


have obtain have obtain intro suffices obtain suffices this.le apply refine rw rw exact apply exact suffices obtain rw exact rw apply


ext1 have obtain simp cases simp have have simp simpa


cases obtain induction nil cons rcases rw exact


apply rw rintro wlog rw induction zero succ ih have obtain exact rw exact


rintro dsimp rw have split_ifs exact exact


rw unfold rw refine rintro dsimp rw rw by_cases simp obtain simp_all


obtain induction change have constructor rw signAux_eq_signAux2 intro rw rw


let have let hg.2 have conv congr rw simp_rw rw


ext suffices a a obtain rw clear induction nil refine rw cons rw rcases refine rw by_cases rw refine rw refine rw


obtain have apply intro exact rw simp_rw


suffices rw constructor induction one swap_mul rw sign_swap induction one swap_mul rw sign_swap


refine intro subst suffices rw exact exact


contrapose simp_rw induction nil cons rw simp grind


simp constructor intro constructor intro by_contra rw exact intro rw rintro specialize by_cases rw rw exact


ext simp exists_eq_right, by_cases simp simp


contrapose classical revert apply simp intro rw apply rw exact


classical induction empty insert hrec have hs.mono rw rw apply intro apply simp


simp push_neg apply convert rw simp intro simp rintro simp h.right.left.symm]


induction nil cons intro rw rw rcases rw rw refine simpa


ext simp by_cases rw grind rw simp rintro exact


constructor obtain obtain rw refine ext have by_cases have rw have obtain rw rw obtain exact


obtain induction exact exact exact rename_i change rw exact


delta induction induction inl induction of mul rw exact one inr mul


simp have rw split_ifs rcases exact rw by_contra have apply rw simpa simp mul_eq_left, constructor intro apply_fun simp equiv_mul_left_of_mem rcases rw erw simp contradiction rw dsimp split_ifs rcases rw simp_all push_neg by_cases simp simp


rcases rcases dsimp rw subst simp have rw simp


Monoid.PushoutI.NormalWord.consRecOn

rcases convert simp induction empty cons ih convert cons simp apply simp mul_inv_cancel, rwa


classical induction empty cons ih rcases refine rwa exact simp


rcases rcases rcases have rw suffices simp ext simp rw


ext constructor rintro refine simp rintro refine simpa


classical let have rw exact apply suffices rw apply apply


classical obtain rw let have rw exact replace rw refine rw exact


let let change refine refine exact rintro rw refine exact rintro rw refine refine rw apply rw exact


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


letI haveI obtain haveI let replace replace refine calc calc


by_cases simp_rw haveI rw have relIndex_dvd_index_of_normal refine haveI have rank_le_index_mul_rank have refine dvd_trans apply intro have g.1.2 simpa


have have rw rw replace replace rw refine exact


contrapose have rw exact have rw exact have rw exact obtain replace rw relIndex_top_right] have have exact


have have contrapose have rw refine have have have rw refine rw exact obtain refine have refine rwa rwa rw intro rw exact


haveI refine rw haveI normalizer_eq_top_iff.mp exact


revert induction ind rintro refine haveI exact


by_cases rw rw exact by_cases rw have rw exact have apply rw exact exact


obtain obtain refine clear induction zero exact f.range_eq_map hfg succ


rw obtain contrapose refine induction zero succ


refine suffices induction ind rcases infer_instance obtain use rw rw clear induction zero rw succ


let let let have refine induction zero succ rw exact


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


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


obtain simp rw suffices rw exact rw intro rw apply rw exact


nontriviality suffices rw two_mul_card_alternatingGroup, exact


let let have rw simp decide rw refine rw have exact


have rw rw have rw norm_num rw swap rw interval_cases exact simp have have rw card_support_swap simp rw decide contradiction


rw rintro simp simp intro have have rw rw rw exact rw obtain simp let have simp rw rw have simp rw suffices suffices exact rw suffices simp


nontriviality obtain by_contra suffices rwa ext refine rw refine contrapose rw exact


rw obtain rw suffices rw rw exact rw exact apply rw exact


split_ifs rw mul_assoc] rw rw split_ifs rw obtain exact contradiction rfl


by_contra replace suffices obtain suffices simp rwa rw exact


rw rw simp by_contra let obtain have by_cases rw by_cases rw rw set suffices apply rw we which but and have rw convert rw apply rw simp apply apply have rw simp have rw simp have simp rw rw simp exact


ext refine simp_rw exists_and_right, use ext rw exact


rw have rw exact have intro have have interval_cases rfl rw exact contrapose obtain rw have replace simp rw rw interval_cases


classical refine obtain replace convert simp simp_rw refine rw apply rw decide


have rw rintro simp rw rcases convert simpa convert rw simp rw apply rw decide


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


classical have obtain use rw obtain have rw intro simp rintro convert rw exact intro rcases use simp rw exact aesop use simp rw ext suffices rw rw exact


obtain obtain suffices use simp_rw grind so


intro by_cases use simpa by_cases rw replace obtain simp refine simp grind simp grind have obtain refine simp grind simp grind


obtain rw apply use simpa let let map_smul rwa


rw wlog rw apply by_cases apply simp apply rw rw grind


have rcases use contrapose convert rw exact


refine obtain obtain obtain exact exact rintro exact


induction rcases cases rcases have have refine simp refine rw have rw simpa


let have apply by_contra simp_rw apply calc c simp apply simp rw refine have contrapose exact simp refine have simp tauto obtain simp simp


have obtain replace rw have refine simp simp have have have simp_all apply refine contrapose exact intro exact


have have immediately refine obtain exact exact orders the have have obtain interval_cases exact simp_all exact


cases rw rw rwa cases rw rwa have rw apply rw apply exact exact


refine cases cases exact cases cases rw exact apply let let rw exact let rw rw exact


rcases rw intro rw apply simpa apply intro have rw injection rw exact


DihedralGroup.exponent

rcases exact apply apply rintro rw refine exact rw exact apply convert exact convert exact


simp rintro have simp_all have have simp


change haveI apply intro simp injection apply_fun apply_fun simp reduceCtorEq] simp


rcases subst simp_rw intro rw apply haveI simpa apply intro have rw injection rw exact


QuaternionGroup.exponent

rw norm_num rcases subst simp exact apply apply rintro rw refine exact rw exact apply convert exact convert exact


rw intro obtain specialize have have exact


let have have let have let refine have contrapose rw exact


rw induction ind rcases rw infer_instance specialize replace let rw exact suffices let rw exact suffices rw let infer_instance suffices simpa rw let have rwa


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


let refine rw exact rw refine obtain rw exact


let have have refine rw replace rwa rw exact


suffices contrapose exact intro have exact


refine have replace rcases replace suffices have exact obtain rw exact have apply rwa


refine obtain have refine hG.isCyclic_commutator, exact rintro have exact


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


constructor intro cases ofNat simp exact negSucc n suffices refine simp simpa intro specialize simp apply


have have rw rintro specialize rwa mul_assoc, obtain simp_rw refine rw


intro rw obtain have let have apply rw exact replace rw exact


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


refine obtain rw apply rw have refine rw rfl


obtain exists_nat_pow_near obtain refine simpa


Sylow.directProductOfNormal

have set let have have rintro haveI haveI have apply apply refine apply rintro haveI letI apply apply apply constructor apply apply rintro haveI haveI have simp apply simp calc congr exact


classical letI calc transfer refine simp rw simp intro simp exact


by_cases rw exact letI classical replace replace key let have replace simpa


classical letI change rw refine dsimp rw simp congr funext apply


subst by_cases have rw have have rw refine obtain rcases rw apply rw refine apply apply rw exact apply apply have have contrapose refine exact


rw by_cases swap have rotate_left exact exact by_cases simp rw rwa exact rw symm simp


by_cases simp by_cases refine rw exact have let have have swap rw exact rw integral_sub simpa


by_cases simp by_cases refine rw exact refine have simp rw


by_cases swap by_cases swap rw exact rw exact


refine have rw rw refine filter_upwards simp have rwa


unfold rw congr exact rwa fun_prop refine rwa fun_prop


apply apply intro have have have rw replace simp rwa exact


obtain have rw subsingleton_iff_singleton exact


rw refine rw rintro simp_rw rw exact rintro exact


rw congr simp constructor rintro exact exact


convert rw vectorSpan_eq_span_vsub_set_right apply rintro use simp


constructor intro rw obtain refine rw rintro exact


refine change rw rw rintro rcases rw use rw rw use rw use rw use refine rw exact sInf_le_sInf hp


rw rw direction_affineSpan_insert constructor rintro rw rcases use symm rw rw rintro use rw


ext simp constructor rintro exact rintro exact


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


refine rw rcases rw rcases have rw rintro simp_all have rw refine convert simp convert simp


rw rw obtain obtain obtain rw by_cases refine rw vsub_add_vsub_cancel exfalso have rw exact have rw exact have rw vsub_left_mem_direction_iff_mem exact


refine by_contra rw obtain have simp_all


constructor contrapose rw intro simp exact


ext have have constructor intro rw refine rw exact intro rw refine rw exact


obtain ext refine have vsub_mem_direction rwa


refine intro suffices obtain rw obtain exact


constructor intro rw refine simp rintro simp


obtain obtain rw use vsub_mem_direction intro rw rcases rw add_comm, refine use rw exact


obtain use ext rw constructor rintro have rwa exact


intro simp induction mem smul_vsub_vadd simp apply exact


ext have rw apply apply haveI let have have have rw


classical intro obtain let have let have simp use simp


let have let have have intro rw let have ext rw constructor rintro exact intro use refine rw rw congr change rw


classical have p intro simp_rw obtain exact obtain obtain let refine simp simp intro obtain refine rw simp have intro by_cases simp replace convert simp simp simp simp


classical let have let have intro simp_rw by_cases have intro convert simp_rw exact obtain refine obtain refine convert simp grind


classical obtain refine rw exact rw exact intro obtain refine convert simp by_cases


rcases exact let have have simpa obtain have intro obtain refine simpa simp let have have rw simp have rw simp have simp_rw suffices simp_rw simp by_cases rw obtain have have have rw fin_cases have have have suffices rw have have have have suffices rw have rw exact


rw vsub_vadd_eq_vsub_sub, conv_lhs congr skip congr skip ext rw rw


have rw convert refine intro by_cases simp simp


classical rw sdiff_singleton_eq_erase, congr refine simp simp


classical simp_rw constructor rintro exact rintro refine simp


rw s.sum_inter_add_sum_diff convert convert simp exact


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


classical constructor rcases swap rw rintro use set use have rw simp_rw simp use have change rw hv, change congr by_cases simp simp rw rintro use simp rintro exact


classical rw let have rw refine intro simp exact rw convert rw refine simp_all


constructor intro obtain exact rintro classical let have by_cases simp simp_rw have intro simp rw exact


classical have have have rcases have rw have rw exact rwa


classical have rw apply rcases rw refine rw apply


obtain simp obtain simpa have have have rw have add_le_add_left erw simpa


obtain simpa obtain simp have have have rw have add_lt_add_left erw simpa


constructor intro let have rw intro rw exact


rw rcases rw rw convert rw infer_instance


simp_rw constructor rintro use intro obtain use rw exact rintro use intro have rw intro rw rw rcases rcases use simp have rwa


rcases simp rw constructor exact rintro use intro rcases rcases use simp


rw use intro rw rcases use simp use simp


rw rcases rcases rcases rw refine have rintro simp simp


rw by_contra have apply apply apply have rw exact


by_cases have intro have conv_lhs exact exact rw exact rw rcases rw rw convert rw convert rw refine gcongr refine have rw rcases refine ext exact


constructor exact intro rw rw replace simpa


classical constructor intro rw intro set let have rw have rw rw dsimp rw exact have set set have simp refine rw rw exact exact intro rw intro rw let have rw convert have simp_rw have exact


rw constructor intro have let convert ext exact intro let convert


rw constructor intro simpa intro have have rw exact


classical intro let let have intro have have simp_rw have rw simp have rw congr simp_all rw


AffineIndependent.map'

rcases apply obtain rw simp_rw have exact


classical ext simp_rw constructor rintro rw replace refine rw convert refine intro rw rw refine intro rw simp intro rw simp grind


classical rw obtain intro have vsub_mem_vectorSpan rw obtain let have simp exact have rw simp let have let have rw exact have rw exact let have have have have have simp


constructor intro by_cases simp simp by_cases rw exact by_cases rw exact simp have rcases exact exact intro rcases rfl simp


classical rw simp obtain simp let refine on_goal suffices convert rename by_cases all_goals


rw refine rcases refine rw have simp_rw hw₂, have rw exact rcases refine let change rw congr


rcases exact obtain have rw refine apply rwa rw apply have simp vectorSpan_eq_span_vsub_set_right congr change rw simp use simp exact


rw let have rintro ext fin_cases simp simp haveI refine rw simpa


classical intro let let by_cases refine let have have have let have simp_rw rw simpa rw exact rw let have simp_rw rw rintro exact have simp_rw rw rintro exact intro by_cases rw exact exact


have rw convert ext fin_cases refine intro refine simp_rw intro fin_cases


cases rw intro have ext change rw replace simpa


cases suffices rw rintro exact intro have calc have apply intro rw change simp_rw rw exact


constructor rintro exact rintro let change exact