rw induction zero succ simp rw norm_cast simp apply rintro rw intro simp obtain cases simp


SimpleGraph.Copy.completeBipartiteGraph

have rw exact let have rw exact let let refine refine rcases all_goals rw exact rw exact


ext simp intro apply intro cases inl inr intro cases inl inr


rw constructor intro ext simp exact intro have conv_lhs simp exact


refine rintro obtain rw rwa rw intro obtain obtain exact


constructor rw rintro obtain exact rintro simpa


intro rw rwa f.topEmbedding.map_adj_iff]


simp use simp ext simp obtain obtain simp_rw


SimpleGraph.topEmbeddingOfNotCliqueFree

simp obtain have apply simpa rw convert exact


SimpleGraph.CliqueFree.replaceVertex

contrapose obtain rw by_cases obtain by_cases obtain have simp_rw rwa unfold use intro simp rw convert use simp_rw conv exact


classical constructor simp_rw exact rintro exact


obtain use have have rw insert_erase exact


classical refine push_cast exact simp rintro simp refine


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


constructor rintro have let use intro exact rintro refine exact rintro simp exact


rw apply intro by_contra simp obtain have exact


refine rw intro by_contra let classical exact simp rintro contrapose refine dsimp simpa


rw intro rw intro contrapose intro exact


classical by_contra have obtain apply suffices apply grind rw have grind


refine contrapose obtain have contrapose simp refine contrapose have simp_all


refine contrapose by_cases simp simp obtain exact


cases zero succ have apply have contrapose exact


contrapose rw refine induction rw exact use rw exact


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


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


simp_rw constructor intro have norm_cast apply intro obtain use intro apply h c.toSimpleGraph_hom rw have exact


constructor rintro induction nil cons intro induction refl tail


let by_cases exact exact termination_by decreasing_by rw lia exact


rintro contradiction have rw contradiction


rw constructor rintro exact rintro exact


apply intro simp_all obtain subst exact simp intro exact


constructor rintro use simp_rw rintro simpa rintro refine simp exact


have let let let have simp have have rw rw exact


classical simp obtain rwa refine obtain obtain exact have let have have exact


rintro obtain refine rintro obtain simpa exact


rintro obtain constructor convert rintro by_contra exact


refine rw apply grw exact obtain simpa rw refine rwa


refine exact refine by_cases apply exact obtain by_cases exact exact


classical obtain have exact hw.disjoint_edges_takeUntil_dropUntil


refine have suffices exact le_trans exact


induction nil rw apply cons rw refine refine apply


induction nil cons cases simp true_or] simp right exact


constructor intro unfold p simp cases inl use simp refine exact inr obtain use simp constructor exact simp rintro rw exact


have ext simp_all refine rintro apply aesop


have simp rcases have apply rw simp have apply rw contradiction


have ext simp_all refine rintro apply simp_all apply aesop


simp obtain by_cases have rw exact rw exact


simp induction simp obtain obtain use have rw have lia obtain use rwa simp rintro exact


constructor intro refine exists simp intro rw rintro obtain exact


rw rw apply simp apply simp simp rw simp


obtain obtain apply rintro simp obtain refine induce_union_connected


classical obtain refine simp exact apply simp exact intro simp obtain refine simp exact simp refine


induction zero succ ih simp ext simp congr rename_i have simp rw


constructor intro refine refine simp rintro exact


simp_rw classical cases rw simp rw congr ext simp_rw and_comm]


classical cases rw simp rw simp_rw exact


induction rw subst rfl cases simp simp split_ifs


induction rw subst simp cases simp simp split_ifs


induction nil rw subst simp cons cases simp simp split_ifs subst simp rw split_ifs simp obtain exact cases apply


ext constructor rintro simpa rintro refine simp


constructor rintro refine simp rintro exact


classical rw convert card_singleton adj_sub edge_vert simp refine ext simp exact


rw rintro have rw exact set have clear_value rw subst obtain let have rw have simp not_exists] refine rw congr exact


classical obtain simp let calc simp rw simp simp


ext simp constructor rintro exact rintro rfl


classical rw rw apply rw intro apply rwa


classical have simp rw rw simp rw convert exact intro rw tauto


rcases have have use rw exact rwa exact have ext rw simp rw refine lia rwa


haveI rcases have rw apply rcases rw exact


classical refine have simp coe_edgeFinset, exact classical simpa h


refine refine rw refine exact apply exact


have rw gcongr exact rw obtain rw simpa obtain rw simpa have rw norm_cast refine push_cast have have gcongr refine exact refine exact


constructor intro have have exact intro rw intro rw exact


refine contrapose simp contrapose simp rw use simpa


cases rw exact by_cases obtain obtain apply rw exact rw exact


refine use intro exact obtain have rw exact


rw refine use exact obtain intro rw exact


refine let let by_contra suffices symm rw rintro by_contra obtain obtain exact


rw constructor rintro refine exact refine rintro rw rfl


classical constructor rintro obtain exact rintro obtain obtain let simp_rw exact


classical rcases dsimp rw have exact let let have h'.symm have refine apply simp apply


let rw and_intros on_goal all_goals rw intro let replace rw simpa rw convert


rw and_intros on_goal all_goals rw intro apply contrapose exact


simp_rw refine contrapose use simp rintro simp rw


rintro obtain obtain simpa exists_and_right] exact hGab le_sup_right.trans_eq


rw wlog replace exact classical use have lia


have have have rw classical use have have have rw have unfold simp_rw by_cases simpa rw have rw congr simp_rw split_ifs have lia


set by_contra rw obtain obtain obtain apply rw use have have have by_contra rw rw degree_eq_card_sub_part_card have lia


by_contra obtain have refine contrapose exact rw exact


set apply by_contra rw obtain apply rw have simp_rw and_comm, intro exact use convert convert rwa


classical obtain use intro simp_rw have rw rw rcases rw have rw rfl


rcases suffices rw rw apply change rw simp have rw change rwa rw simp rw


rw simp_rw conv_lhs enter rw rw add_assoc, congr rw conv_rhs congr rw conv_rhs rw congr


rcases rw have rw have nth_rw show rw rcases rw have rw rw let have rw congr have rw have n n rw rw rw add_comm congr rw


grw rw grw exact rw gcongr rcases rw exact


rcases rw simp_rw exact obtain convert rw


let suffices obtain simpa use apply rw exact use intro rw positivity


have apply simp_rw have rw use intro simp simpa


classical rw apply rw use constructor rw apply rw constructor simpa rw exact


rcases simp have apply obtain simpa obtain simpa


cases haveI haveI intro haveI haveI exact obtain refine exact unfold simp⟩ intro simp target have have rw apply simp


intro have have obtain obtain rw cases inl cases inl subst_vars inr apply exact inr apply exact


obtain let have classical obtain exact hj.not_ge


classical r refine contrapose obtain exact


classical obtain have rw simpa have h₁.disjoint use refine simp rcases exact use have simp exact


classical obtain have simpa refine have grind


classical obtain have simpa have h₁.disjoint have h₁.disjoint have let let refine exact exact exact exact


classical obtain use have rw exact refine simp split exact obtain exact


classical refine intro have haveI have have exact obtain have have let have have he_not_in_cycle have by_cases subst exact have have have rw have have exact let have exact


simp and_self_iff] split_ifs revert refine intro rw simp congr ext simp revert refine intro simp


ext dsimp split_ifs subst exact exact simp sum_const_zero]


rw intro split_ifs rfl rw exact rw exact rfl


rw intro rw have simp repeat ext simp rw intro obtain exact


intro rw use ext simp rw simp mem_univ, rfl


ext induction rw constructor intro use rw intro induction rw exact


SimpleGraph.Subgraph.IsMatching.sup

intro have obtain use refine intro cases inl inr rw simpa cases inl inr rw exact


SimpleGraph.Subgraph.IsMatching.iSup

intro obtain obtain use refine intro obtain by_cases exact have simp simpa


intro obtain use refine obtain simp exact obtain rw


use verts adj_sub intro obtain exact exact edge_vert simp intro rcases use simp rintro rfl exact use simp rintro exact simp


SimpleGraph.Subgraph.IsMatching.map

rintro obtain use refine rintro cases rw


refine rintro simpa obtain obtain rw exact exact hc


by_contra have intro obtain obtain use have refine apply simp hwnu, trivial apply haveI classical haveI simpa


SimpleGraph.IsMatchingFree.mono

intro by_contra apply refine intro simp exact


obtain use refine intro obtain simp_rw aesop


let have ext simp subgraphOfAdj_adj, aesop exact


intro obtain obtain simp not_or, by_cases simp_all right use aesop


classical by_cases subst use have obtain have intro exact hw'1 by_cases subst have simp exact exact have apply simp have rw refine exact have simp refine exact use termination_by decreasing_by have simp_wf have lia


by_cases rwa intro simp obtain exact rw simp rcases subst exact simp_all rw simp rcases subst exact aesop aesop


rw intro simp obtain by_cases obtain have use simp not_true_eq_false, rintro aesop obtain by_contra simp_all use simp and_self, rintro exact have simp_all


cases inl inr cases inl inr obtain obtain rw exact


classical have apply calc p.length rw apply


refine obtain obtain let have have have lia


use have have rw p.tail.length_tail_add_one simp lia)] lia have by_cases have lia by_cases have lia exact


rw intro have rw obtain contrapose simp_all aesop


have rw card_sdiff_of_subset congr rw unfold aesop


have rw card_union_of_disjoint congr rw unfold aesop


constructor rintro have rw apply rintro refine generalize_proofs change have rw exact


classical let have rw have intro refine apply simpa exact


rintro have intro simp have rw rw exact exact


have let have obtain obtain refine have lia


have let have hn obtain obtain refine have lia


intro induction nil simp by_cases lia simp have exact simp have exact simp have lia


refine induction nil cons intro rw refine intro simp have hinj lia), obtain have hinj lia


intro simp have have hpc.reverse.getVert_injOn simp show lia


intro have by_cases rw lia have hpc.getVert_injOn lia


induction nil cons simp split_ifs exact simp


induction nil cons simp split_ifs trans apply rw lia rw exact


induction nil cons simp split_ifs exfalso simp apply calc p.length simp rw


induction nil cons simp split_ifs apply apply assumption rw apply assumption


induction nil cons simp split_ifs apply apply rw exact


induction nil cons rw simp intro cases exact


unfold rw have rcases simp rw congr simp congr


classical constructor intro exact intro exact


classical have simp_rw by_cases rw aesop have have have let have refine calc have rw exact


obtain simpa have have have apply rw grw rw have grw simp div_le_iff₀ nsmul_eq_mul, ring_nf rfl


have have rw swap sz_positivity refine calc rw refine rw calc gcongr exact calc rw refine have rw rw gcongr exact have sz_positivity rw card_sdiff_of_subset exact


have rw refine rw one_div_div] refine norm_num apply sz_positivity


have rw refine exact refine conv_rhs simp conv_lhs rw simp push_cast apply simp rintro rw refine rw refine refine exact rw gcongr apply apply refine exacts


have rw refine exact refine conv_lhs simp conv_rhs rw simp push_cast apply simp intro rw refine rw refine rw gcongr exacts sum_card_subset_chunk_parts_le exact rw apply exact exact refine exacts


rw constructor rw exact suffices ε apply gcongr rw apply


obtain refine exact exact exact rw have calc exact gcongr have have refine rw rw norm_cast


have have have calc gcongr exacts rw gcongr exact gcongr exact gcongr sz_positivity exact rw refine have rw linarith


rw set set set set set have have unfold exact have have have average_density_near_total_density simp_rw norm_num exact have rw rw cases left right


obtain refine simp exact induction by_cases simp subst exact simp_rw set obtain n rw split_ifs refine rw refine rw which least of induction by_cases obtain have have rw obtain hcard refine simp exact exact simp_rw split_ifs rw rw exact intro obtain obtain have have rw obtain refine simp exact conv simp refine simp obtain rw exact refine simpa apply exact simp exact simp split_ifs rw rw intro


refine rw have rw exact nth_rw rw refine intro apply exact


have have rw simp_rw rw any_goals rw congr rw


rintro simp true_and, refine rintro obtain exact


calc rw norm_num rw gcongr rw exact gcongr rw calc rw nsmul_eq_mul, gcongr calc gcongr rw norm_cast rw refine nlinarith norm_num


obtain le_total refine rw exact let have obtain obtain exact have rw exact suffices obtain refine rw gcongr simp calc intro induction zero refine rw exact succ obtain by_cases refine rw exact hP₃.trans replace have have have rw norm_num rwa have hP₃.trans have refine le_trans rw exact rw exact rw gcongr


refine rw obtain replace exact obtain replace exact rwa


calc gcongr obtain simp refine exact mul_pos norm_cast gcongr calc simp rintro exact_mod_cast rw exact


obtain simp calc mod_cast simpa suffices rwa have refine simp


obtain simp apply rw have refine suffices rw convert rwa positivity


calc simp rintro rw exact rw apply norm_cast exact


rintro simp mem_interedges_iff] intro replace obtain obtain obtain exact by_cases exact exact


simp simp_rw have rw rw rw simp intro simp rintro


letI rw obtain convert simp simp intro rw simp_rw have rw exact rw card_singleton, congr simp simp_rw congr intro simp_rw simp_rw congr


ext simp compl_adj] rw obtain rw simp simp by_cases simp not_false_eq_true, rw rw


constructor intro simp rintro exact rintro exact


intro constructor intro simp apply intro simp intro apply


refine simp exact simp exact simp rintro exact simp rintro exact


refine rintro simp classical exact simpa


refine ext rw simp intro have have rw subst_vars exact


ext simp and_congr_right_iff] intro constructor intro refine rintro simp contrapose rintro intro exact


ext simp constructor intro simp obtain intro simp obtain first exact simp


induction nil cons rw specialize simp split_ifs rw obtain rw simp false_and, rintro exact have grind


subst simp simp obtain simp right convert_to simp congr ext simp


classical have ext simp is3Clique_iff] constructor rintro simp obtain any_goals any_goals first exact exact exact simp exact simp exact simp exact rintro refine constructor rw rintro simp rw rintro refine simp rintro refine hG simp


rw refine simp rintro have refine rw refine simp simpa mem_cliqueSet_iff]


refine rw refine simpa simp rintro calc simp and_imp, rintro


rw by_contra have by_contra refine simp obtain rw refine choose let have obtain dsimp have rw obtain exact exact


simp rw simp obtain have have rw have have rw push_cast have refine refine ring


classical have have let have triangle_split_helper refine rw apply rw have suffices exact have rw mul_comm refine rw gcongr rintro rw simp aesop


apply rw refine rintro simp rintro simp apply


rw obtain ht cases cases cases have have have have have linarith calc exact


let let let calc rw norm_cast rw gcongr exact gcongr exact exact


cases simp obtain apply let have rcases calc obtain have have rw replace obtain exact


refine rw obtain obtain refine obtain obtain obtain obtain rintro exact


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


classical refine unfold convert rw obtain exact


refine sup_le_iff.mpr simpa refine rw simp simp simpa


classical have obtain simp rwa have have rw exact choose let have refine rw hcomplMatch_compl exact have rw exact have rw intro by_cases exact right simp use aesop exact


classical cases obtain obtain refine simp rw exact


classical by_cases use exact by_cases use exact simp have have aesop suffices obtain have apply simp use apply let have have have have have have refine simp exact le_trans by_cases use refine simp refine rw rw simp_all have have have rw exact obtain obtain obtain hp.1.exists_isCycle_snd_verts_eq obtain use simp rwa refine simp htw have apply rw aesop rwa simp obtain exacts have rw intro apply have simp aesop have refine obtain obtain rw exact rw exact simp obtain exact tutte_exists_isAlternating_isCycles conv enter rw rw exact tutte_exists_isAlternating_isCycles


SimpleGraph.tutte

classical refine contrapose intro by_cases exact exact


nontriviality obtain refine simp have simpa


nontriviality refine grw by_contra have grw simp obtain have refine rw refine refine grw simp obtain have grind


induction nil cons rename_i by_cases obtain exact exact


intro induction nil cons cases nil cons simp grind


induction nil cons simp split_ifs simp obtain simp rw simp


induction nil cases exact simp obtain exact cons rw cases simp obtain exact rw obtain obtain exact


refine rw getVert_eq_support_getElem simp


suffices intro cases inl rw exact inr replace have rw rw


cases nil constructor rintro simp rintro simp cons constructor rintro rintro


refine grind have refine simp simp apply simp drop_support_eq_support_drop_min, rw simp


cases nil cons cases zero succ simp_rw exact


rw ext simp by_cases cases contradiction simp have grind simp


refine subst simp refine rw rcases rcases dsimp subst ext rfl exact


refine subst simp rcases rcases dsimp subst ext rfl exact


ext simp and_congr_right_iff] rintro rfl


induction zero succ refine rw apply left refine rw exact right refine rw exact obtain refine calc pair comp obtain exact obtain have intro induction zero apply lia succ simp apply rcases rw gcongr rw apply rcases rw exact rw apply rw exact ack_mono_left exact


cases inl have filter_upwards have simp refine refine filter_upwards inr refine filter_upwards positivity


let have have calc b have have calc b obtain rw refine have filter_upwards rw refine refine calc refine calc b


rw intro let have refine differentiableOn_one_sub_smoothingFn rw rw exact have calc deriv filter_upwards rw refine calc calc filter_upwards rw have refine calc filter_upwards have simp refine simp_rw refine have have calc filter_upwards refine have have refine rwa calc calc b positivity filter_upwards have q have simp ring change rw exact


rw intro let have refine differentiableOn_one_add_smoothingFn rw rw exact have calc deriv filter_upwards rw refine calc calc filter_upwards rw have refine calc exact filter_upwards have simp refine simp_rw refine have have calc exact filter_upwards refine have have refine change rw exact calc calc b positivity filter_upwards have q have simp ring change rw exact


let have simp_rw have calc exact_mod_cast


let have rw obtain filter_upwards eventually_ge_atTop eventually_forall_ge_atTop.mpr eventually_forall_ge_atTop.mpr eventually_forall_ge_atTop.mpr eventually_forall_ge_atTop.mpr eventually_gt_atTop eventually_forall_ge_atTop.mpr eventually_forall_ge_atTop.mpr eventually_forall_ge_atTop.mpr eventually_forall_ge_atTop.mpr h_asympBound_pos h_sumTransform have let set refine have intro rw have have rw rw calc have have rw induction ind h_ind have exact_mod_cast calc have calc gcongr exact by_cases exact h_base simp_all mem_Ico, exact h_ind a g g g gcongr positivity refine rw exact exact g congr refine rw exact n g g gcongr positivity positivity exact ring rw gcongr refine rw calc gcongr rw exact


let have rw obtain filter_upwards eventually_ge_atTop eventually_forall_ge_atTop.mpr eventually_forall_ge_atTop.mpr eventually_forall_ge_atTop.mpr eventually_gt_atTop eventually_forall_ge_atTop.mpr eventually_forall_ge_atTop.mpr eventually_forall_ge_atTop.mpr eventually_forall_ge_atTop.mpr eventually_forall_ge_atTop.mpr h_smoothing_pos h_smoothingFn_floor have set base_min_def let have refine obtain calc have have rw exact have refine calc positivity refine have intro rw have have rw rw calc have have rw induction ind h_ind have exact_mod_cast calc have calc gcongr exact cases inl inr exact h_ind a g g g gcongr positivity refine rw exact exact g congr refine rw exact n g g gcongr positivity positivity exact ring rw gcongr refine rw calc gcongr refine calc exp


intro have obtain refine filter_upwards intro rw exact


obtain rw filter_upwards obtain have calc have intro induction zero simp specialize simp refine simp simp succ intro simp have calc x specialize specialize rw gcongr norm_num lia simp refine rw have have rw rw exact have simp exact refine rw refine rw simp calc rw refine rw simp have rw refine rw exact exact_mod_cast


obtain left filter_upwards have rw exact have have rw have exact right filter_upwards have rw exact have have rw have exact have simp rw obtain refine rw refine refine grind intro have have grind obtain cases inl inr right filter_upwards exact


by_cases exact cases inl refine simp rw exact inr refine simp rw exact


intro obtain refine filter_upwards intro simp exact


cases inl hf have filter_upwards rw rw exact inr hf have filter_upwards simp rw exact


intro refine refine filter_upwards simp exact


suffices cases inl cases inl hg have filter_upwards rw rwa inr hg have filter_upwards simp simp exact inr cases inl hg have filter_upwards rw simp exact inr hg have filter_upwards simp simp exact intro have have obtain obtain refine refine filter_upwards intro refine calc c₁ gcongr exact exact calc f gcongr exact exact


intro have have obtain obtain refine refine filter_upwards intro have calc b have have refine calc min gcongr exact exact gcongr exact exact calc max gcongr exact exact gcongr exact exact


intro have rw cases inl have obtain specialize refine filter_upwards hx_nonneg have have calc have calc have calc f intro have have calc refine calc f calc inr have obtain specialize refine filter_upwards hx_nonneg have have calc have calc have calc f rw gcongr refine rwa intro have have calc refine calc f rw gcongr refine rwa calc rw gcongr rwa


cases inl refine have filter_upwards intro simp inr hf_pos_or_neg suffices cases inl hf have filter_upwards rw rwa inr hf have filter_upwards simp rw exact have cases inl inr simp have intro have obtain refine refine filter_upwards intro have refine rw gcongr exact rw gcongr exact


intro obtain have have cases inl refine refine filter_upwards intro have refine calc c₁ calc inr refine filter_upwards intro simp simp rw refine refine filter_upwards intro refine calc c₂ calc have rw exact


intro have refine refine have filter_upwards h_tendsto.eventually x intro refine calc rw gcongr calc exact


intro have have have obtain obtain have obtain obtain have have refine refine have have filter_upwards hg_bound intro have calc b have refine calc c₁ exact rw exact calc f gcongr rw exact


have have rw have filter_upwards simp calc b congr exact


obtain filter_upwards have calc rw exact


let have have have linarith have have have calc b refine have rw have filter_upwards intro rw simp calc r


induction ind cases inl inr rw have refine exact


have rw refine filter_upwards have change positivity


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


have tendsto_rpow_atBot_of_base_lt_one refine refine positivity


obtain obtain have refine filter_upwards hn_pos have have cases inl calc sumTransform gcongr rw have refine rw refine calc c₁ rw exact rw simp rw rw inr calc sumTransform gcongr rw have refine rw refine calc c₁ gcongr rw have calc exact exact rw simp ring


obtain obtain obtain have have refine filter_upwards hrpos intro have have cases inl calc sumTransform gcongr rw have refine rw refine calc c₁ gcongr rw have calc positivity rw exact exact rw rw inr calc sumTransform gcongr rw have refine rw refine calc c₁ gcongr rw have calc positivity rw exact exact gcongr exact rw rw rw


induction head use simp cons rcases use simp


obtain wlog exact refine rw simp omega intro have simp omega have rw min_eq_left use rwa


rw rcases induction nil cons have rw rw apply intro exact


obtain use intro rw rcases rw rcases rw substs have rwa


induction nil rw constructor intro use rw trivial simp_rw intro exact append_singleton rw constructor intro obtain rw simp_rw obtain use rw tauto simp_rw intro rw obtain use rw simp_rw tauto


rw suffices ext simp apply simp intro rw rfl


Nat.Partrec.merge'

obtain obtain have refine have x intro obtain revert simp rcases exact subst exact refine intro rw simp obtain refine simp refine rcases exact exact


Partrec.merge'

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


ComputablePred.rice

obtain obtain fixed_point₂ simp by_cases simp change rwa simp rw contradiction


classical exact have or_iff_not_imp_left.2 let rice


induction prim comp rfind have have exact


constructor rintro refine simp exact rintro exact


induction zero succ simp constructor rintro exact rintro rw exact


ext rw suffices induction nil append_singleton


rw simp constructor rintro left right rintro


simp induction nil rw exact cons rw rw exact


induction zero succ left right pair refine simp comp prec refine simp induction zero succ simp exact


intro rcases have intro induction zero succ rcases exact cases rcases obtain injection exact suffices b rcases exact intro apply intro rcases refine simpa rwa rcases grind


intro let letI letI letI letI cond have option_bind option_bind option_map fst.comp have have have have have have have have let n.casesOn n.casesOn have nat_casesOn nat_casesOn nat_casesOn nat_casesOn this.comp snd.pair refine iterate simp let change have simp exact have have simp rw simp cases


intro let letI letI letI letI cond have refine refine option_bind refine option_map fst.comp exact have have have have have have have have let n.casesOn n.casesOn have nat_casesOn nat_casesOn nat_casesOn nat_casesOn this.comp snd.pair refine iterate simp let change have simp exact have have simp rw simp cases


refine induction zero succ left right pair rcases exact comp rcases exact prec rcases exact rfind rcases refine simp rintro induction zero succ left right pair comp prec rfind


refine rsuffices exact induction pair rcases rcases refine refine evaln_mono rfl⟩ comp rcases rcases refine exact evaln_mono prec revert generalize induction zero intro rcases exact succ intro rcases rcases refine evaln_mono evaln_mono simp exact rfind rcases suffices simpa revert generalize intro induction zero simp rcases exact succ rcases rcases rcases simpa use rw use use use simpa


have have refine replace have refine have have have have apply have have have have have refine unfold conv congr ext dsimp erw refine unfold exact have have have have have refine unfold have exact have have have have have have refine have have have have refine have have have have hlup.comp exact have have have have have have have refine have refine unfold exact


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


induction single have rwa rcases have rw rcases exact


induction refl tail rcases rcases have revert rcases intro cases intro rcases cases exact cases exact


obtain rcases cases refine have rcases rfl rw rcases rcases cases


classical intro induction simp branch rcases unfold exact grind grind goto halt rcases exact grind


classical constructor apply constructor simp exact apply intro rcases obtain simp rw simp cases simp have revert induction move cases unfold exact write cases unfold exact load refine unfold exact branch cases refine unfold exact refine unfold exact goto cases exact halt


suffices intro induction zero succ rw simp rw


obtain simp suffices intro induction nil cons simp convert simp


suffices refine simp intro induction zero succ


simp suffices stepAux stepAux clear intro induction nil cons rcases rw simp


suffices rw simp obtain simp suffices stepAux stepAux intro exact clear intro subst induction nil cons trans dsimp simp cases rw rfl


letI let have list_casesOn to₂ let have suffices refine rw introv dsimp generalize generalize induction zero succ simp rcases


haveI let let let i.rec have to₂ have nat_rec have to₂ nat_rec to₂ listFilterMap to₂ option_map have option_map exact option_some_iff.mp this.of_eq have graph have have induction succ have mapGraph induction cons have rcases simpa have graph have induction zero succ ih simp bindList_succ, apply intro exact exact simp


Nat.Primrec'.sqrt

suffices simp have have exact head exact have have exact introv induction zero succ dsimp exact exact


rcases exact rcases rw split rw split simp_rw simp_rw


induction nil rw constructor intro refine rw rwa rintro obtain subst repeat simp cons rw split_ifs rw constructor rintro exact exact rintro rcases right rw rw exact left rw refine rw convert exact rw constructor exact rcases contradiction rw refine rw convert exact


induction zero rw tauto epsilon char rw rfl plus rw rfl comp simp tauto star


rsuffices obtain exact simp rfl⟩ clear induction zero succ obtain obtain exact simp rfl⟩


induction prim induction zero succ get refine exact obtain exact comp obtain obtain simp refine rw specialize replace simp simp simp induction succ suffices a have simp_all intro induction zero refine simp rfl succ refine simp exact comp obtain replace simp show refine simp succ_eval, constructor rintro suffices v v₁ clear intro refine clear rintro have simp split_ifs simp reduceCtorEq] subst exact refine obtain exacts rintro refine have generalize clear induction zero succ refine simp


induction cons₁ rw rfl comp fix split_ifs rw rw rfl


refine simp constructor suffices x c intro obtain refine simp split_ifs rw exact exact refine rintro have rw obtain rw swap exact cases refine rw revert by_cases refine rw exact exact obtain have rw simp obtain refine simp split_ifs exact rintro rw swap exact refine rw obtain obtain split_ifs refine rw swap exact rwa obtain split_ifs clear refine rw swap exact rw exact


induction cons rw simp rw exact rw refine exact comp rw simp rw exact rw simp cases fix


induction halt simp exact cons₁ rw simp rw exact rw cons₂ comp rw simp rw exact rw fix rw split_ifs simp congr exact


induction nil rw swap rw refine simp grind cons refine rw rcases cases cases swap cases rcases rw cases simp convert simp simp


refine simp cases convert simp rw simp simp convert simp rw simp


induction nil refine rw revert cases rfl simp revert cases rcases rw cons refine rw rcases cases cases swap cases rcases rw cases simp convert


induction nil refine simp cons refine rw simp elim_update_rev, pop', exact


let refine cases rw simp trList] rw refine exact convert


rcases refine rw simp elim_rev, convert simp refine simp elim_update_rev, refine convert simp


simp rcases refine simp convert simp rfl simp suffices obtain simp refine convert simp induction one refine simp bit1 obtain refine simp rfl bit0 refine simp simp rfl


rcases refine simp refine simp refine simp rcases simp refine rw convert simp simp suffices obtain simp refine convert simp induction one refine simp bit1 obtain refine simp rfl bit0 obtain refine simp rfl


induction zero succ tail let refine simp swap refine cases cons obtain refine simp elim_update_rev] refine convert simp comp rw simp obtain revert obtain exact obtain exact fix


induction halt cons₁ obtain refine refine simp elim_update_aux] refine pick_goal exact refine simp id_eq, exact cons₂ obtain exact comp obtain exact fix rw have natEnd obtain exact rcases simp rw cases by_cases obtain refine rw exact obtain refine rw convert simp convert exact exact


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


induction move clear copy push read succ pred ret all_goals simp repeat simp intro simp exact constructor rintro apply intro simp exact refine exact rcases exact


have cases halt cons₁ cons₂ comp fix rw have intro refine exact


have induction move clear copy push read succ pred ret simp any_goals obtain first have try exact supports_insert.2 exact supports_insert.2 exact supports_insert.2 exact supports_insert.2 refine supports_insert.2 exact refine supports_insert.2 exact refine supports_insert.2 refine refine exact exact exact supports_singleton.2


induction zero succ tail cons apply rw exact comp simp exact fix


induction cons have refine refine refine simp exact refine rw exact exact comp have refine refine refine simp exact exact have refine exact fix have refine refine refine simp exact exact


induction halt cons₁ have refine refine simp exact cons₂ have exact comp have exact fix rw exact


Turing.ListBlank.ext

refine wlog cases intro rw refine refine simp simp rcases simp rw


induction zero cases simp succ cases rw simp simp


induction repeat oracle pair comp prec rfind repeat


TuringReducible.trans

induction repeat oracle pair comp prec rfind


classical intro induction simp branch rcases unfold exact exact exact goto halt load rcases unfold exact exact


simp cases push have refine rw erw rw rfl⟩ refine rw by_cases subst split_ifs rw simp rw rcases rw simpa rw simp split_ifs rw peek rw use cases rw addBottom_nth_snd, rfl pop rcases simp iterate_zero_apply, rw exact refine erw iterate_succ', addBottom_modifyNth show rw refine rw by_cases subst split_ifs rw rfl rw rw rcases rw simpa rw simp split_ifs rw


induction zero succ apply rw simp rw rfl rwa


induction zero succ refine simp rw iterate_succ', rfl


simp have obtain have rw obtain refine rw exact


intro obtain rsuffices exact simp generalize induction run load branch unfold beta_reduce cases goto halt


rw refine refine rw have rfl rw simp by_cases subst simp rw simp rw cases rw congr simp rfl


refine intro obtain exact intro obtain refine dsimp ext obtain rw change have rwa


simp pointwiseLeftKanExtension_desc_app] apply aesop


dsimp simp rw ext apply intro suffices erw simp congr ext simp apply intro rw simp letI apply ext simp rw simp rw simpa


ext simp types_id_apply] simp have apply presheaf_ext intro erw simp functorToPresheaves_obj_map, ext erw rfl


dsimp rw refine have have rw constructor change rw exact


dsimp rw refine have inferInstanceAs have rw constructor change rw exact


apply change apply simp exact have exact exact


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


rw refine specialize obtain refine simp specialize obtain refine simp


rw refine specialize obtain refine rw simp simp specialize obtain refine rw simp


rw refine specialize obtain refine rw simp specialize obtain refine rw simp


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


let have generalize replace rw revert dsimp generalize suffices induction zero intro rw congr ext rw rfl rw simpa succ intro rw congr ext have apply lia rw rw


unfold rw generalize rw generalize induction nil cons


dsimp apply ext cases intros rw dsimp suffices ext cases


dsimp apply ext cases intros simp apply congr


classical by_cases simp constructor exact have rw obtain replace suffices subst exact obtain revert wlog rcases replace apply simp simp intro


by_cases rcases exists intro have obtain exact exists intro simp obtain cases


apply intro obtain trans trans apply apply apply dsimp rfl apply simp intro apply


rw apply simp intro induction zero succ trans apply apply


rw apply apply intro exists apply apply intro exists


by_cases rw rcases exact simp rw replace rw cases


rw ext constructor intro obtain simp intro obtain refine


rw ext constructor intro obtain simp intro simp obtain refine


instCountableForallOfFinite

have induction zero succ rcases have exact


rw refine intro simp simp not_not] simp refine intro simp simp


rcases change rw intro dsimp split_ifs rfl rw


constructor intro by_cases subst exact have have have rw rw rw exact rintro rw rw


DFinsupp.induction

obtain induction obtain induction empty have subst exact cons have dsimp have have rw apply have rw change rcases rw exact grind


refine rintro rw refine convert exact refine ext dsimp exact


refine by_contra refine rw notMem_support_iff.1 exact


obtain classical have obtain refine exact


obtain ext dsimp rw obtain rw obtain rw rw simpa simp


ext dsimp rw obtain rw obtain rw rw simpa simp


apply refine rw exact rintro refine refine by_cases simp simp


rintro simp_rw split_ifs refine simp simp split_ifs rwa assumption ext1 simp split_ifs rw rw rw refine simp exact split_ifs rwa assumption ext1 simp split_ifs rw rw simpa


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


induction refine refine rintro rw split_ifs swap exact subst classical refine obtain exact by_cases rw exact exact


induction empty cons simp refine refine rw exact


induction empty cons simp refine exact exact


induction empty cons simp_rw refine gcongr exacts


obtain suffices by_contra have calc simp_all exact


constructor rintro rw simp rintro rw simp


cases top lift rw rcases coe rcases have simp rw rw


lift lift have obtain refine simpa refine rwa rwa


ext simp constructor rintro exact rintro constructor apply exact apply exact


obtain simp exact apply exact simp refine simp apply simpa


by_cases simp obtain simp obtain obtain simpa exact


obtain simp obtain obtain rw rw exact exact


have lift lift cases simp norm_cast rw exact


obtain rw simp replace refine obtain simp rw exact exact


obtain rw exact simp_rw refine le_antisymm add_le_of_le_tsub_right_of_le rw exact


rcases simpa rcases simpa have have simp


obtain simp obtain simp nth_rewrite assumption


apply intro cases top coe contrapose apply intro specialize have use simp


refine obtain simp obtain simp cases top coe d have rw intro obtain exact obtain rw apply


intro induction rw induction rcases exact simp simp exact


intro simp induction rcases rw rw rw simp


rcases rw rcases simp rw exact simp induction rw exact induction rw exact simp


induction rcases simp simp rcases simp simp rw exact simp


rcases simp rcases simp rcases rw simp induction rw induction rw apply apply simp simp


ext constructor rintro lift simpa intro use simpa


constructor rintro exact contrapose intro exact


induction simp by_cases simp simp exact simp_all


constructor intro refine rw cases simp left right rintro exact all_goals


induction bot top coe rcases rw max_eq_left rw rw simp congr exact


induction bot top coe rcases rw ofReal_inv_of_pos coe_neg simp rw ofReal_inv_of_pos coe_inv congr exact


rcases rcases rw exact obtain use rw rwa have obtain exact


rcases rw rcases obtain exact rcases rcases obtain rw refine rw rw obtain exact


refine obtain replace replace obtain exact


constructor rintro rw exact cases bot top coe


rcases rcases obtain simpa lift exact exact


rcases lift rw sub_zero] rfl rw zero_sub, exact


induction try rename_i by_cases rw exact rw simp


induction bot simp simp coe top simp refine by_contra exact


FP.ofPosRatDn

let obtain let let obtain let let refine exact


induction nil cons ih simp refine simp simp


have rcases rcases simp_rw by_cases exact by_cases exact refine dsimp lia


constructor intro exact refine simp intro rw obtain obtain exact exact


refine induction zero succ obtain rcases refine refine simpa


have refine rw suffices intro induction zero succ rw exact


rintro unfold split_ifs exact rw cases rw cases exact


ext rw refine rw refine rw simp rw simp rw simp


ext refine intro rw exact intro rw exact


generalize_proofs apply rw refine simp simp


ext cases zero succ cases last cast rw simp


funext rcases simp rcases simp split_ifs have simp have simp


funext rcases simp castLT_mk] split_ifs have contradiction obtain simp have contradiction


simp split_ifs generalize_proofs generalize rw intro generalize_proofs generalize rw intro


refine ext apply trans rw exact apply rw


have refine cases left right exact rw exact


induction zero succ simp_rw constructor intro exact induction zero succ rw refine rw obtain rw injection rw obtain dsimp rw obtain rw exact


ext induction zero have subst simp succ induction last cast


ext simp_rw split_ifs rcases simp simp simp rcases simp rw simp


ext simp_rw split_ifs rw exact rw simp refine lia


ext simp_rw cases zero obtain simp succ split_ifs simp rw simp refine lia


Function.Embedding.finite

rcases infer_instance refine haveI exact


refine simp_rw by_contra exact rintro exact exact


induction nil cons obtain simp refine rintro simp


classical refine grind grind intro simp intro exact


classical have ext suffices simpa constructor intro rintro calc apply intro exact


classical calc apply intro simpa congr ext constructor obtain obtain


rcases simp classical let apply aesop intro rw simp exact


classical by_contra refine intro contrapose exact


refine obtain exact exact rintro rw exact


classical simp_rw exists_comm constructor rintro exact rintro exact


by_cases exact exact let exact let exact


classical refine rintro refine convert exact refine ext exact


classical induction empty insert simp split_ifs rw exact


classical induction empty insert simp split_ifs have simp have simp


classical induction empty insert rw simp


rw constructor rintro simp simp_rw rintro refine rw


constructor rintro simp exact rintro simp rcases exact


constructor intro letI lift refine ext grind


induction empty cons obtain exact exact cons


ext simp_rw constructor rintro exact rintro exact


classical induction empty simpa notMem_empty] insert intro have rw apply obtain obtain h obtain use rw exact


cases exact obtain refine classical have rwa


apply induction empty cons rw exact let exact


classical induction empty insert rw cases inl inr simp rcases rw exact rw apply


induction singleton cons rcases rw cases inl inr


induction empty insert rw refine simp refine h hg have have h simpa rw obtain simpa simpa


replace intro rcases rcases exact set have intro rcases calc f calc s.card image_subset_iff.2 insert_subset_insert


induction rcases simp simp have simp rcases rw refine rw exact


ext simp constructor rintro obtain exact rintro exact


classical induction empty insert specialize rw by_cases rw exact simp_rw obtain rwa exact h).trans_subset


ext suffices refine rw rintro refine rw exact


rw simp induction nil cons rw intro exact


induction simp induction nil cons rw congr apply intro simp apply cases cases


obtain obtain rw calc noncommProd noncommProd noncommProd


ext apply intro exact convert intro exact intro rw mul_one] simp intro simp simp intro simp


rintro simp_rw obtain obtain obtain exact exact


apply rw refine dedup dedup dedup subst congr exact


cases induction subst rcases convert simpa rcases rcases set clear_value have rw apply rw rw clear rw refine rw exacts


simp_rw rintro simp exists_eq_left, refine cases


refine rw exact mem_powersetCard.mpr rcases exact


apply simp_rw rintro exact rw intro simp obtain powersetCard_nonempty.2 refine rw exact


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


let apply have obtain rw exact have exact


let apply have exact have obtain rw exact


induction zero refine rintro exact succ refine rintro rw obtain rw obtain exact exact obtain exact


set ext by_cases simp exfalso exact exact


ext classical by_cases suffices simp suffices apply simpa


ext simp constructor intro refine simp_rw intro replace simp_rw obtain exact simp_rw exact rintro exact


simp_rw constructor rintro exact rintro exact


refine intro exact intro exact refine exact


classical rw simp_rw by_cases rw convert refine exact rw refine exact


intro ext classical by_cases rw apply exact simp_all


rcases simp_rw rw support_single_ne_zero rw exact


classical intro cases exact obtain exact


induction nil cons simp simp rw suffices exact rw intro simp obtain exact


induction obtain suffices convert dsimp simp simp exact


classical suffices convert exact obtain refine simp subst rwa intro exact


ext simp constructor grind intro classical choose use grind


classical simp_rw split_ifs refine exact exact


intro simp simp use constructor intro simp simp


refine rw intro rw toMultiset_single, rfl


constructor intro contrapose rcases rw intro cases inl inr


classical induction zero add rw simp rw all_goals single


rw intro rw simp intro rw exact intro have rcases intro rw rw


rcases split_ifs subst simp apply simp rw simp_all


classical constructor intro by_cases refine rwa rw have have grind grind


classical have have rcases use constructor ext rw grind exact


obtain ext by_cases subst classical suffices have classical rw


classical simp by_cases rw refine apply exact simp rw apply


classical simp trans apply exact rw rw exact


classical constructor intro ext simp by_contra apply rw exact intro rw


classical set suffices exact intro rw simp exists_eq_right] use ext dsimp grw simp


induction zero succ obtain obtain obtain exact


classical induction zero succ rw refine simp obtain obtain exact


classical suffices simp intro refine simp


classical have rcases exact choose have set have intro induction have rw exact refine conv_rhs rw apply exact


rcases refine rcases exact exact unfold apply exact


intro have cases have eq_of_subset_of_card_le have obtain exact


classical cases have simp_rw exact exact


obtain induction rcases apply apply intro rw exact


rw refine dsimp clear letI rw rw exact classical rw simp mul_comm]


rintro letI wlog exact by_contra have refine refine rw


induction zero succ rcases exact obtain obtain refine simp


have rw exact refine by_contra let have have grind


fintypeNodupList

refine let let refine simp unfold use constructor simp rfl convert ext unfold refine intro simp rw have rw rw simp rw constructor intro by_contra rw contrapose use simp intro simp intro by_contra absurd rw exact intro simp constructor intro rcases convert rw rfl intro exact


Fintype.truncRecEmptyOption

suffices apply intro apply intro exact intro induction zero have apply intro apply exact succ ih have apply intro apply intro exact


induction nil simp exact cons by_cases refine rintro exact have have intro have rintro apply simp refine simp split_ifs exacts suffices simpa refine exact rw


constructor simp rintro rw exact simp exact


classical by_contra cases let complete exact


refine rw rcases contrapose infer_instance


apply rw intro apply intro rw rcases subst exact


classical induction empty obtain use simp insert have have obtain have use simp_rw rintro simp rw exact ne_of_apply_ne hfs.ne exact


classical let have have obtain refine apply simpa


apply ext rw simp rw simp intro have simp intro exfalso exact


refine constructor rintro rfl exact rintro obtain exact exact


refine rw congr refine rw rw rw rw rw exact


funext rcases try simp rw congr funext cases simp congr simp


funext rcases try simp rw congr funext cases congr simp


funext rcases try simp congr simp congr simp rw congr funext cases rfl


rw unfold_projs cases simp mul_def] grind simp grind


have rw max_eq_left conv_lhs rw tactic rw rw neg_lt_neg_iff, exact


have rw conv_lhs rw rw split_ifs rw cast_pos, exact rw neg_eq_neg_one_mul, exact


rcases dsimp rw rw simp add_neg_cancel_comm_assoc, symm calc have obtain rw simp rw simp


constructor intro rw exact rintro rw exact


cases ofNat induction zero succ negSucc suffices intro induction zero succ


apply obtain rw obtain change have subst have subst refine congr symm rw


obtain simp ext simp constructor rintro exact rintro have obtain refine calc n calc i rw refine exact rw refine simp exact rw


constructor intro exact intro constructor rw simp rw


rcases rw exact rcases rw rw apply exact rw have have rw lt_inv_comm₀ refine exact


rcases have rw exact rw exact obtain rfl rw exact


intro by_cases exact refine obtain all_goals refine obtain all_goals exact


intro simp split_ifs simp exact simp rw exact


obtain suffices cases apply convert rw apply


constructor intro intro induction rfl cases cases congr subsingleton apply


refine induction nil singleton cons_cons ih refine apply rw


cases nil cons apply cases nil simp exact cons rw refine rw rcases by_contra rw apply apply exact simp_all


obtain apply specialize rw induction intro have let have rcases apply rintro apply ih revert rw clear_value induction intro intro apply rintro apply apply apply


induction nil cons rcases simp by_cases rw rw simpa


induction nil cons rcases simp by_cases simp rw simpa


revert suffices intro induction nil cons rcases exact rw split_ifs exact exact


rw subst intro obtain grind suffices rcases simp rw rw refine rw rw rw simp getElem_cons_succ] simp lia simpa


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


nil x unfold split_ifs grind apply grind


cases nil cons by_cases subst simp grind rw congr rw all_goals


obtain have have rw simp_rw rw simp_rw rw simp simpa


Cycle.Subsingleton.congr

induction simp length_eq_one_iff, rcases


rw rcases simp simp simp refine simp exact


obtain induction rcases simp simp simp simp


induction nil cons intro have have rw apply rw refine pairwise_append.2 rw rcases exact rw rw exact rw rw exact


refine refine have have rw lia have have rw exact


induction nil cons simp rw by_cases rw rw


induction nil cons rw rw by_cases rw rw rw exact


induction nil cons rw split_ifs exact exact


induction nil cons rw split_ifs simp assumption


rw induction nil append_singleton cases simp simp


rw induction nil append_singleton cases exact simp


intro rw rw rdrop_eq_reverse_drop_reverse]


refine obtain exact exact rcases simpa exact


induction slnil cons cons₂ rw rcases simp simp


induction nil cons by_cases simp rw refine cases assumption contradiction


refine refine intro exact intro rw simp_rw exact


funext constructor intro induction rfl simp rintro exact


constructor induction nil obtain exact cons_right obtain exact obtain revert induction slnil intro rw exact cons cons₂ intro obtain exact


simp constructor rintro obtain use simpa rintro use simp


induction nil cons ih simp pure_bind, generalize have rw simp


induction nil cons cases nil cons obtain simpa


intro induction nil cons simp simp cases rfl simp simp simp rw refine simpa simpa


rintro induction nil cons obtain obtain rw exact


cases nil cons rw cases none simp rfl some


induction nil cons cases simpa simp swap rcases simpa simpa simpa rcases exact trans refine grind


rw cases nil cons cases nil cons rw exact


induction nil append_singleton intro rw rcases rw rw simp_all rw dsimp split_ifs exact simp_all exact simp_all


cases bot coe rw simp cases none some have rw rw exact all_goals


induction nil cons rw by_cases simp simp


induction nil cons obtain simp exact exact


induction nil cons simp obtain exact exact


cases nil cons simp rw exact rw nil_append, exact


cases nil cons cases nil cons tl rw modifyLast_append_of_right_ne_nil modifyLast_append_of_right_ne_nil all_goals


induction nil cons specialize by_cases simpa rw rcases simp suffices exact


induction nil cons simp simp rintro rfl apply apply apply


induction nil cons rw simp by_cases subst simp simp


induction nil cons have rw obtain let dsimp rw rw exact have intro rw simp rw exact rw apply rw exact


constructor intro induction slnil cons obtain refine simpa cons₂ obtain refine rintro rintro simp simpa rintro exact


rw constructor rintro have intro specialize rw obtain exact refine simp intro apply simpa rintro refine intro dsimp split_ifs rwa lia exact simpa grind


classical rw constructor rintro refine rw rintro refine rintro simp simp simp simp simp rintro simpa simpa


induction nil cons ihl have split_ifs rw simp have split_ifs rw simp simp have split_ifs


letI simp intro specialize contrapose rw suffices calc rw exact


rcases simp_rw constructor rintro exact rintro exact


constructor rw intro have have have have simp_all intro rw have simp intro have simp_all rw simp_all


by_cases rw cases inl have rw inr have have rw have have simp have aesop


constructor intro exact intro rw intro rw


List.HasPeriod.factor

suffices intro have rw all_goals have have rw rw exact lia lia have simp_all rw exact


rcases simp_all rcases simp_all rw have suffices intro have intro by_cases calc have have have calc calc have rw


List.HasPeriod.gcd

rcases simp_all rcases simp_all cases lt have exact eq gt have have have exact have have exact have apply all_goals have have rw have lia have let convert_to rw exact have convert_to rw exact termination_by decreasing_by


wlog rw cases inl rw cases inl inr apply intro rw grind grind inr


cases inl rw cases intro rw rel_congr_right inr rw rw


induction nil cons obtain rcases exact swap obtain obtain exact trans rcases rcases exact


funext constructor intro rcases have rcases exact exact


induction nil cons by_cases have simp by_cases simp refine change rw solve_by_elim simp


by_cases let have have rw apply rw apply apply grind


induction nil cons simp rw refine simp intro


induction nil cons rw constructor rintro exact exact rintro simp simp rcases exact


induction nil cons ih simp append_assoc] congr funext rw simp simp


show refine introv rw rcases exact have simp rcases simp exact exact


show refine intro rw rcases clear subst rcases subst have rcases exact exact exact


induction nil cons simp apply have map map intro simp change refine rw exact refine rw exact


List.Perm.permutations'

induction nil cons swap dsimp rw apply intro apply trans


obtain induction zero succ refine rw have simp refine rw refine refine congr funext rw


induction nil simp simp cons cases simp simpa


induction nil cons rw by_cases subst simpa rw simp count_eq_zero_of_not_mem,


induction nil cons simp simp refine rw exact simp


refine obtain rw apply have have rw rw have rw exact


rw induction nil rw rw constructor intro rw rw exact refine rw rintro obtain obtain rw have simp rw have simp have simp rcases suffices rw exact simp rw exact suffices rw exact


refine contrapose rw intro rw obtain rw use rw exact take_sublist


constructor intro induction nil rw exact cons rw rcases exact obtain exact exact


induction zero succ simp cases zero succ n simp isChain_append_cons_cons, rw


induction nil cons simp constructor intro obtain intro rw rw lia rw apply intro apply exact


induction nil cons simp conv_rhs apply intro simp


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


rw constructor intro rw obtain rw obtain use simp_rw intro rw


rw induction zero succ rcases simp rw exact


rw rcases rw rw rw have rw congr rw have have rw exact conv_rhs lia rwa


rw induction zero succ rcases simp rw simp


rw simp_rw rw let rcases simp_all rcases simp rw exact exact


refine obtain rcases simp refine refine simp


induction nil append_singleton simp apply apply


constructor simp_rw rintro exact rintro rw apply


refine induction cases exact simp rcases simp induction nil simp exact


rcases apply rw lia cases nil rw exact cons apply rw lia


rcases apply rw lia cases nil rw exact cons apply simp exact exact


induction intro induction intro refine rcases exact cases nil simp refine apply rw exact simp refine apply rw exact


refine rintro dsimp split_ifs subst simp simp_all simp_all rfl simp


induction nil cons by_cases subst exact simp rcases exact rcases exact


by_cases subst induction nil cons by_cases subst simp by_cases subst simp simp


induction nil cons simp by_cases subst simp simp


induction nil cons obtain by_cases substs cases subst simp subst simp simp


dsimp generalize have rw apply clear induction nil cons cases simp constructor simp apply exact


induction nil cons obtain by_cases subst rw rw exact


simp induction nil cons simp trans apply assumption


induction nil cons simp rcases simp rw by_cases subst simp simp


induction nil cons obtain by_cases subst simp simp


induction nil cons simp_rw simp_rw rw simpa simpa


cases nil cons cases nil cons unfold cases exact have simp exact have exact have rw exact simp_all exact


induction nil cons cases cons cons₂ obtain exact


classical obtain induction nil cons cases cons cons₂ specialize have have exact


induction nil cons simp_rw split conv_rhs simp


induction nil cons rw split exact rw simpa


induction nil rw obtain cases apply rw exact cons simp split apply grind rw obtain apply rw exact grind


induction nil rw apply simpa cons rw split apply intro obtain refine rwa apply simpa rw apply simpa


induction nil cons rw by_cases rw exact rw flatten_zipWith exact flatten a cases nil cons cases nil cons


simp induction nil cons rcases rw rw split_ifs rw subst simp cases


simp induction nil cons cases suffices exact simp specialize grind grind simp have rw


induction nil simp exact cons simp constructor rcases exact exact obtain exact exact


induction simp exact singleton_sublist.2


induction zero succ induction slnil cons refine rw apply cons₂


induction slnil rcases simp rw exact cons₂ rw exact


rw induction nil have simp append_singleton ih rw simp rcases rw exact rw apply rw exact


rw induction nil simp_all cons rw simp] rcases exact exact


induction nil cons rw rw obtain rw exact rw obtain exact


induction nil cons rw specialize rw refine intro simp obtain intro simp intro simp rintro


induction nil cons simp cases head tail refine rw refine rw exact


induction nil cons simp rw refine refine simp simp_rw intro simp_rw rintro exact exact simp simp intro rw obtain obtain simp obtain exact exact


induction nil cons simp obtain rw refine rw exact rw exact exact simp


induction nil cons simp exact swap simp conv rw refine simp simp trans


induction slnil cons simp exact cons₂ simp exact


induction nil cons simp rcases have exact


induction nil cons by_cases simp_all rw simp


rcases simp rw by_cases simp intro replace have simp lia simp


induction cons cases simp rw rcases exact exact


induction simp set rcases have rw exact simpa rw simp simpa


ext simp cases inl rw rintro lia inr rcases rw exact


induction nil cons simp refine grind simpa simpa


induction simp constructor rintro simp simp rcases simp intro right use simp_all


ext dsimp obtain rw exact obtain rw exact simp


cases exact obtain refine simp obtain rw obtain rfl exact rw obtain rw rw


constructor inhabit ext classical replace simpa rw exact


constructor intro exact intro obtain simpa exact


ext dsimp obtain rw obtain rw rw obtain rw obtain rw rw


obtain classical use split_ifs simp simp refine simp


dsimp rcases simp rw simp rintro simp simp


intro refine simp intro use rcases rcases rw use simp use simp


rw constructor rintro exact rintro exact


induction empty cons hs simp_rw erase_cons_head] rw congr refine rw


induction empty cons obtain rw simp exact


Multiset.IsDershowitzMannaLT.trans

classical rintro rw refine simpa rwa rw rwa simp refine obtain by_cases obtain exact exact obtain exact


classical obtain obtain refine simpa refine rw rw have simpa rw have simpa


induction rintro induction refine obtain exact clear induction empty simp obtain exact


induction empty constructor simp cons exact


classical rintro induction empty cons obtain exact let refine rw simp simpa


fconstructor intro by_contra have exact contrapose exact


by_cases exact rw rintro rw contradiction


revert rw by_cases rw congr by_cases rw rw rw by_cases rw rw


simp_rw rintro obtain rw exact obtain by_contra replace simpa h have simpa lia exact


Multiset.traverse

refine introv induction nil h have simpa swap l have rw congr funext simpa simp trans


constructor intro obtain refine rw rintro simp


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


induction empty cons by_cases cases simp rw


induction empty cons rcases simp replace rw


intro induction empty cons obtain obtain exact


apply simp rintro refine rcases on_goal all_goals


induction empty have simp intro cons simp_rw constructor rintro by_cases subst rwa rw apply intro refine rw


induction nil cons simp exact swap simp apply rw exact trans


induction zero succ induction nil cons simp exact swap simp apply cases simp simp rw exact trans


rw constructor rintro have rwa intro rw exact


induction empty cons by_cases simpa simp


apply rw refine rw exact rw refine rw exact


rw refine rw exact rintro exact rintro exact


haveI constructor intro by_cases subst simp_all have have rcases simp have have simpa intro rcases simp simp


refine suffices introv revert refine introv rcases exact


constructor intro induction intro subst exact


constructor generalize intro induction zero ih rcases subst subst exact rcases exact exact


induction zero intro rcases exact rcases exact


revert refine intro rw intro rw obtain obtain refine exact simpa


Multiset.Rel.trans

induction empty cons obtain obtain exact


rw constructor have rw refine norm_cast rw exact


rcases simp by_cases have apply rintro exact exact simp apply contrapose exact


rcases simp exact have apply rintro exact exact


obtain set have rw split_ifs rw have have rw exact obtain use rwa


induction refl intro rwa step intro rw exact


induction refl intro refine rw step intro obtain obtain refine rw


by_cases obtain simp unfold exact rw change generalize rw intros


induction zero bit hs suffices cases exact


induction zero bit hs have cases simpa simp


cases nil cons obtain simp_rw have refine rwa simp exact have simp simp obtain have simp simp nth_rw rw simp termination_by


funext induction zero bit rw simp_rw induction zero bit rw simp_rw eq_rec_constant,


induction zero simp cases succ conv_lhs rw cases


induction zero bit by_cases subst rw revert cases refine obtain rw obtain refine obtain exact


induction zero rw rintro simp bit induction zero bit by_cases subst simp have eq_of_testBit_eq rw exact obtain simp have exact


funext simp induction ind rcases specialize simp


set have have have rw obtain have contrapose simp_rw rw rfl obtain on_goal on_goal on_goal all_goals refine rw rfl simp


induction zero succ nth_rw rw rw rw rfl rw refine rw rfl


induction ind cases zero succ rw by_cases conv rw rw conv rw have rw simp


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


induction zero succ hk grw gcongr rw exact


induction nil cons have simp constructor rintro cases intro


induction nil cons ih have simp intro exact simp


cases nil cons simp have simp intro exact refine simp intro exact


induction nil cons simp have simp intro exact exact chineseRemainder_modEq_unique


rcases rcases apply rw apply lia rw apply


by_cases simp cases zero succ rcases rw exact rw exact


induction rcases clear norm_num obtain calc


have have have have have apply exact rw sum_Ico_consecutive factorization_prod_apply factorization_mul sum_congr


induction zero succ ih simp factorization_mul ring


apply have simp rw factorization_eq_card_pow_dvd_of_lt log_pow have rwa nth_rewrite exact


by_cases simp have have refine simp rw exact


rcases exact rcases simp simp and_imp] intro rcases rw exact lt_of_le_of_lt replace have calc n rwa


conv_rhs rw apply intro rw contrapose rw intro simp


have simpa simp simp conv_lhs enter rw have intro rw constructor simp have rw exact rw simp rw split_ifs simp rw cases


simp classical by_cases rw support_update_zero] congr exact rw rw


dsimp convert rw ext1 rw split_ifs rw rw


classical induction empty cons rw simp sum_add_distrib, suffices p s.noncommProd n.choose rw simp rw hc simp refine rw refine rw rw congr rw rw intro rw exact refine rw exact


induction empty rw rintro rw swap exact convert convert simp rw haveI apply insert intro rw exact simp_rw refine rw conv simp_rw rw rw congr


rw rw refine rw refine rw rw rw rw exact exact


let change have simp have have intro have dsimp rw congr rw rw by_cases rw rw rw induction zero rw dsimp rw succ ih rw add_mul, congr rw


by_cases simp apply calc congr rw rw congr rw


trans refine intro rw rw exact refine rw refine rw


rcases cases simp dsimp rw congr simp simp apply


induction nil cons dsimp replace rw rw intro apply exact intro rw convert exact by_cases rcases left simpa right contrapose refine rw exact


rcases rcases rfl simp rcases induction zero succ rw simp induction ind cases rw rfl simp dsimp rw rw


constructor intro have convert rw rintro simp


induction nil simp exact cons obtain simp simp have have simpa simp have rw


induction ind intro rcases rw cases rw cases exact apply apply assumption


induction nil cons rw have mul_le_mul suffices exact


induction zero succ induction zero succ nth_rw rw exact


induction zero succ rw ofDigits_div_eq_ofDigits_tail


induction zero succ cases nil cons tl rw add_mod, mul_mod_mul_left, apply apply exact rw exact


induction zero succ simp specialize simp exact


induction zero succ simp cases zero succ cases zero rw simp succ specialize split_ifs simp simp


induction rw by_cases simp aesop have rw refine contrapose exact


rcases cases cases simp cases cases simp exact revert induction ind intro by_cases simpa rw refine rw exact


rcases simp rw refine rcases by_cases simp exact exact


rw simp ofDigits_singleton, apply refine have convert rw


obtain induction nil cons ih simp digits_ofDigits simp rw simp obtain simp have have have simp have rw have rw sum_Ico_consecutive mul_add, nth_rw rw simp simp cases rfl simp


induction zero one bit rw cases rw simpa simpa simpa


induction nil cons dsimp dsimp conv_lhs conv_rhs


by_cases rcases simp nth_rw rw exact rcases


obtain clear rw induction zero ind rcases rw simp simp


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


induction zero succ by_cases simp rw simp sum_cons] rw simp_rw rw ring


refine have intro rw exact induction refl step


cases rw apply apply assumption rw exact succ


cases zero cases simp simp succ apply simp rw


obtain clear induction zero succ rw have rw exact


obtain suffices obtain refine simpa refine norm_cast rw


induction zero succ simp refine rw exact


refine rw contrapose refine rwa contrapose exact


constructor intro by_cases simp right rw exact rintro simp simp


refine rcases have intro rw by_contra obtain rwa


rcases simp rcases simp rcases cases have have rw intro rcases simp simp_rw exact


refine rcases simp rw by_contra apply rw simpa


rcases simp rcases simp exact refine rw intro simp_rw exact


let let have intro have exact have have suffices apply rw exact rw exact intro rcases simp contradiction have have simp


rcases simp ext simp iff_and_self] exact


ext simp refine rcases rw exact rw apply


constructor rintro simp intro refine by_cases simp simp


nth_rw rw apply exact intro obtain rw simp intro simp


induction zero succ rw by_cases simp simp


by_cases symm by_cases simp_all use simp_all by_cases use simp_all let set use suffices refine apply simp apply intro have rw suffices refine simpa


set let let have rcases exact exact have conv_lhs conv_rhs rw have rcases exact exact exact exact


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


refine rintro induction zero succ rw exact


apply rintro simp simp rintro rw simp intro rw factorization_mul_of_coprime exact


rw refine dsimp any_goals refine contrapose


rcases simp rcases simp nth_rewrite rw apply rw apply intro rw intros


rcases simp rcases simp nth_rewrite rw apply apply rw intro rw intros


rw refine constructor rintro exact rintro have rintro simp_all rw exact rfl⟩


rcases rcases rcases refine simp refine refine rw simp


refine rcases rw rw refine contrapose simp


rw constructor rintro refine rintro exact rintro rcases cases refine simp apply apply rw intro rw cases simp


rcases simp rcases simp refine i.trans obtain simp hp.pow_dvd_iff_le_factorization have rw intro simpa rcases


rcases simp simp rcases simp simp ext simp not_false_iff, apply


obtain simp obtain simp obtain simp rw factorization_pow,


obtain aesop obtain simp rw factorization_pow,


constructor rcases exact exact rw injection rcases exact exact


refine rw refine rintro rw exact simp_rw exact simp_rw exact


rcases exact rcases exact exact use nth_rw rw


induction zero succ constructor rw rintro rw exact rintro rw rw primeFactorsList_prime exact


obtain contradiction contradiction simp exact


induction zero succ specialize rw simp ring


refine have refine rwa rw refine rw exact


induction zero rw simp rintro exact succ by_cases rw constructor rintro exact rintro rcases exacts rw grind


induction refl step rw split_ifs exact exact


induction zero succ by_cases rw rw exact


rcases simp rcases simp rcases simp rcases rw rwa suffices rw mod_mod, rw


intro obtain cop.symm.dvd_of_dvd_mul_right obtain cop.dvd_of_dvd_mul_right rw refine rw


rw refine rcases simp_all rcases simp_all rw rw simpa


by_contra rw have apply rw right assumption


classical constructor intro rw exact exact assumption rintro rw exact


classical obtain rw obtain exact suffices rw exact have rw rw exact


suffices convert simp_rw obtain refine le_csInf le_of_not_gt dsimp rwa exact


induction zero succ cases inl inr hnb rcases simp_all split


rcases simp rcases simp rcases refine rw le_log_iff_pow_le rw rwa


induction zero succ cases inr inl hbn rcases simp_all split


obtain rw exact cases zero rw exact succ


rcases simp rcases refine rw lt_clog_iff_pow_lt suffices apply grind


dsimp rw by_cases have rw have rw nth_rw rw exact rw simp


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


have have have have have have rw exact revert have intro rw rw exact simp_rw intro rw sum_const_zero,


induction zero succ ih simp congr rw and


have emultiplicity rw have rw hp.emultiplicity_factorial hp.emultiplicity_factorial multiplicity_choose_aux simp refine apply exact


have refine exact intro by_cases subst simp simp rw exact decide have rw rw push_cast apply exact cases simpa suffices simpa rw refine exact


by_cases exact rcases rw refine rcases exact


rcases rcases rcases rwa rw exact rcases rwa


by_cases exact simp have rcases exact have have rw rwa


by_cases induction rw refine have grind push_neg rcases rw exact


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


have ext refine rcases exact induction simp_rw replace rw rcases exact repeat have rw convert nth_rw convert exact rcases exact


have intro contrapose exact rw refine exact


classical let have suffices by_contra rw exact


rcases simp refine obtain injection grind


dsimp show have simp show have rw exact simp


by_cases by_cases simp simp apply exact exact simp simp apply exact apply


by_cases simpa simp by_cases simp rw rwa exact


rw constructor rintro by_cases use intro specialize specialize rw lia specialize rw obtain exact rintro exact


constructor rintro exact contrapose rw rintro exact


rcases rcases induction rw exact_mod_cast intro norm_cast exact


induction apply intro rcases exact_mod_cast


refine rcases induction apply intro exact_mod_cast


refine rcases induction rw apply intro exact_mod_cast


rw intro rw have revert contrapose exact


refine intro by_cases apply rw specialize exact exact


rw map_count_True_eq_filter_card, congr exact


constructor contrapose rintro obtain exact rintro


refine have simp suffices obtain apply assumption rintro have obtain subst rw subst simp subst exact refine subst subst rw exact


have let rwa have have have have suffices exact hpd5.elim


refine have refine rintro simp refine rw


by_cases simp have revert rcases simp by_cases exact refine exact


constructor intro by_contra have rw exact rintro simp


constructor intro rw exact intro have have refine suffices exact


convert dsimp rename_i induction zero succ


induction zero succ simp rw by_cases rw rw cases have rw obtain simp obtain rw


rw have refine apply intro by_cases apply rw cases


unfold let dsimp split_ifs suffices refine apply rw rw refine rw show have refine rw exact exact


n have simp refine simp rw refine rw simp refine rw grind


rcases simp rw by_cases have rw simp exact rw exact


refine by_cases have rw hp.dvd_iff_one_le_factorization have have lia rw


refine rcases simp refine have apply rw exact


have have subst contradiction rcases rw exact obtain simp exact


rw by_cases refine have have exact have have have intro have refine have rcases subst contradiction apply intro rw change have rw exact have refine exact split_ifs exact specialize exact exact termination_by


dsimp exact rcases subst cases refine refine refine rintro contradiction rcases subst cases refine refine rintro contradiction


have constructor rcases rfl rw cases rwa


rw intro simp constructor rintro use simp rcases rw rw rw normalizedFactors_mul exact rintro rw have rw intro apply not_irreducible_zero rw refine have rw rw apply intro rw rw apply intro apply rw apply intro apply rw apply


classical set have use have simp let have simp obtain rw obtain rw refine rintro rw by_contra refine convert lt_mul_of_one_lt_right rw simp_rw refine


ext have simp dvd_div_iff_mul_dvd refine hp.1.not_isUnit rw exact


conv_lhs induction zero rw simp gcongr exact succ simp simp_rw calc gcongr apply rw apply


rcases rcases rw apply simp refine rw simp simp refine have rw apply rcases refine rwa


rcases simp rw have nth_rw refine apply nth_rw exact


refine replace apply rwa rintro rw exact rw if_neg refine lia


constructor rw simp_rw exact simp_rw rintro exacts


by_cases simp have have rw exact simp mul_comm_div, refine have have rw


have intro calc a1 congr exact simp rw rotate_left repeat simp rw exact


rcases simp rcases simp have rw refine exact


by_cases rw simp by_cases rw exact obtain suffices rw obtain simp simp refine rintro suffices rw exact rw refine rw exact exact exact


by_cases rw rw refine rw mul_eq_right lia


induction one bit1 bit0 intro obtain unfold try rw cases rfl


intro obtain rw rw cases rw cases rw have have induction one bit1 bit0 obtain any_goals simp show all_goals repeat rw any_goals any_goals any_goals all_goals rw rw


cases symm apply simp induction zero succ simp


obtain symm apply induction zero succ have obtain rw symm apply simp trans apply change rw apply simp trans apply change rw apply simp


cases zero pos rw induction rfl rw rw simp rw rw


induction rw simp simp_rw simp split_ifs rw simp


obtain simp rw swap simp rw rfl simp rw calc rw rfl simp


unfold have intro apply rw simp rcases rw refine obtain rw cases have simp constructor rwa rwa


rw induction one bit1 unfold revert simp apply rw lia bit0 unfold revert simp apply simp rw simpa


have intros simp rw exact intros unfold split_ifs exact rw exact


refine refine cases inl cases cases exact inr


unfold obtain obtain obtain try split_ifs obtain dsimp split_ifs obtain dsimp split_ifs


obtain obtain rfl rw obtain rfl have have rwa cases cases obtain rw all_goals have have rwa cases cases obtain rw all_goals symm dsimp simp simp exact obtain rw obtain rfl have have rwa cases cases obtain rw all_goals have have rwa cases cases obtain rw all_goals symm dsimp simp simp exact simp symm split_ifs have have rwa obtain rw exact obtain exact dsimp simp simp have have rwa obtain rw exact obtain exact dsimp simp simp simp exact


obtain rfl obtain have have rwa cases cases rw replace simp


constructor rintro exact exact rintro rcases exact exact


rw intro rcases exact exact intro rcases exact exact cases exact


Ordnode.balanceL

rcases rcases exact rcases rcases exact exact rcases exact exact rcases exact refine rcases exact rcases exact exact


Ordnode.balance

rcases rcases exact rcases cases exact exact rcases exact exact rcases rcases rcases exact exact rcases exact exact refine rcases exact rcases exact exact rcases exact rcases exact exact


obtain suffices from rcases rw rw rcases rcases rw rw by_cases dsimp have have rw rw revert decide rw decide rcases rw rcases rcases rw rw have have rw have rw exact refine refine rw refine simpa exact exact exact exact exact


Ordnode.Valid'.rotateL

obtain rw rw replace have have have have absurd rw have suffices exact rcases rw have rcases rw rw decide have rw rw decide replace rcases refine exact exact exact exact rcases rw replace rw rw cases refine rcases replace rcases have rw exact exact exact


suffices rcases exact exact exact rw exact


have induction nil node have rcases refine rw rw


obtain obtain dsimp rw obtain suffices refine refine exact exact rw refine rwa rw obtain suffices refine refine exact exact rw refine rwa


rw rw rcases suffices suffices refine rw rw size_balance abel rw intro


induction nil node induction nil node rw obtain exact obtain have rw exact refine


induction nil simp cases cases simp exact node have have clear obtain obtain simp constructor exact constructor rw constructor exact exact constructor rw constructor exact exact


induction nil node simp have have clear obtain obtain cases suffices constructor exact rw repeat exact left have obtain constructor exact right suffices constructor exact rw apply apply exact right


induction nil node have have clear dsimp unfold revert have clear have obtain rw rw have revert cases simp rw have clear have obtain rw rw have revert cases simp


ext dsimp simp constructor rintro exact simp


PFun.fixInduction

have generalize_proofs clear induction intro have exact


constructor rintro rcases refine rw rfl rintro use rw


simp rintro assumption intro repeat first constructor assumption


constructor rintro rcases use constructor rw rfl constructor rw rfl intro exact rintro use dsimp rw rfl rw


ext constructor apply rw intros exact simp cases subst tauto


MvPFunctor.M.bisim

obtain obtain dsimp have refine rintro rcases rcases rcases rw exact subst congr induction obtain obtain cases cases root child


apply clear introv specialize clear revert rcases rcases intro rw injection subst simp have replace simpa exists rw simp intro replace simp replace rw exact


MvPFunctor.M.bisim'

have solve_by_elim apply clear introv have induction rw rwa all_goals


intro apply intro dsimp let dsimp apply apply


change have ext dsimp cases rfl rw have ext1 cases rfl rw dsimp rw have rw


constructor rintro rcases refine rw congr rintro use rw


simp rcases cases assumption repeat first constructor assumption


constructor rintro rcases use constructor rw rfl constructor rw rfl intro exact rintro use constructor rw rfl rw


ext constructor apply rw intro exact simp cases subst tauto


induction zero cases cases rfl succ cases intro simp congr exact


apply intro dsimp induction zero succ dsimp rcases have rw apply revert rw intro congr ext dsimp generalize rw revert rw intro cases rfl


induction zero succ induction constructor try intro


constructor induction zero succ induction induction simp obtain constructor intro apply apply induction zero succ obtain induction induction simp have cases replace cases constructor intro apply simp


induction nil exfalso apply constructor cons obtain induction simp by_cases subst simp rw intro apply constructor apply simp


dsimp congr rcases dsimp dsimp cases dsimp congr


induction zero specialize induction induction simp subst simp succ cases cases induction induction subst iterate rename_i simp have cases have cases congr ext apply solve_by_elim solve_by_elim introv specialize simp exact


PFunctor.M.ext

apply induction zero succ apply rw apply rw apply introv dsimp cases apply


intro induction induction obtain induction nil exists apply cons obtain obtain dsimp have induction induction simp rw obtain apply rw apply


inhabit classical introv introv by_cases have exact rw obtain simp


PFunctor.M.bisim

introv haveI apply constructor replace replace simp rw simp cases cases apply


ext apply clear intro rcases have have refine intro exact


PNat.caseStrongInductionOn

apply rintro rcases exact rcases exact exact


PNat.recOn

rcases induction zero succ rcases exact exact


change rw split_ifs have rw by_cases rw exact let rw exact exact


constructor rcases apply rcases obtain rintro simp use rw


rw rw intro apply rw intro by_cases exact replace rw exact


apply rw rcases dsimp let have simp obtain exact exact


constructor intro rw apply rw intro rw exact


apply apply exact exact rw apply exact exact


apply rw apply exact exact apply exact exact


rw congr apply constructor rw intro rw exact


PNat.findX

have have refine obtain rw exact obtain simpa exact


refine induction one succ intro simp exact


dsimp let constructor simp simp_all simp rw


let rw ext change have rw ring change rw ring


let let ext change rw ring change rw ring


intro let let have have have have constructor exact have let rw have have constructor exact constructor exact have rw ring have rw ring constructor apply rw constructor apply rw grind


rcases apply apply exact exact have have rw rw exact


rcases rw left apply right rw have have exact


constructor intro have simp apply intro simp rcases apply


constructor rintro rcases use constructor rw intro apply rintro use rw


constructor rintro rcases use constructor rw constructor rw intro exact rintro use dsimp rw rw


rw intro have rw refine intro exact exact grind


constructor intro have rw rcases refine intro rintro have exact rintro rintro rcases rw apply intro refine apply intro apply apply


rw obtain rintro rw rintro rw apply intro refine rw exact


constructor rintro have rw dsimp simp exists_imp] constructor rintro simp ext simp


intro rcases intro rcases intro apply let have have intro have appendFun appendFun have intro apply dsimp rw apply let intro apply c clear intro apply r clear intro have rw exact


let intro apply intro left rfl intro cases inl inr have rw dsimp rw rw rw right


MvQPF.Cofix.bisim

apply intro rcases rw rw rw rw congr apply apply change apply


apply dsimp intro rw conv lhs congr rfl rw rw rw rw congr apply funext apply rfl


let refine clear rintro subst dsimp induction simp conv rw apply intros rfl


rw congr mv_bisim rw dsimp repeat apply dsimp intros exact congr erw simp


apply intro apply intro refine intro congr intro intro


intro induction ind abs rw change abs abs rw trans apply apply apply


have apply apply intro apply apply conv lhs rw dsimp rcases rw rw


have apply rw conv rhs rw congr rw rfl rw apply apply


apply intro apply intro change rw apply rw congr rw have ext exact rw


unfold rw conv rhs rw rw have ext apply rw


MvQPF.Fix.ind

apply intro apply change rw apply rw refine intro cases apply trivial


constructor rintro rcases use constructor rw rfl intro apply rintro use rw


constructor rintro rcases use dsimp constructor rw rfl intro apply rintro use rw


constructor rintro rcases use constructor rw rfl constructor rw rfl intro exact rintro use constructor rw rfl rw


induction apply change apply have rw rfl apply


have ext apply rw apply conv lhs rw dsimp rcases rw


rintro induction change rw rw congr apply


QPF.Fix.ind

rintro induction change rw apply rw refine convert


rintro apply let have intro have h have intro apply simp rw apply let rintro exact have rw rw exact


let intro apply intro left rfl intro rcases rw have rw dsimp rw rw right


rw intro have rw exact exact intro rintro rcases rw


constructor intro have rw rcases refine intro rintro have exact rintro rintro rcases rw apply intro refine apply intro apply apply


rw obtain rintro rw rintro rw apply intro refine rw exact


constructor rintro have rw dsimp rw simp constructor rintro simp simp


constructor rw intro induction rel refl symm trans exact


rcases rw lift have refine have obtain simp have simp_rw rw dsimp rw norm_cast rw exact


have refine simp rcases have intro have rcases have rw contradiction rw have rw rw mul_assoc,


generalize generalize rw have have exact


rw obtain simp set obtain rw exact rw refine rwa


rintro constructor simp rw cast_natCast]


rintro constructor simp rw floor_natCast_div_natCast ceil_intCast_div_natCast


suffices suffices have rwa suffices have calc rwa suffices rw simpa have have have rwa exact


have have set have suffices suffices simp field_simp simp suffices have suffices mod_cast have simpa rwa have have have rwa have have have rw rw constructor exact suffices rw exact rwa


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


constructor rintro rw simp rintro refine rw


let have obtain rw nth_rw rw intro have rw rw


let have obtain rw nth_rw repeat apply rw intro have rw rw rw apply rw


unfold rw rw rw norm_cast exact all_goals


have have have rw push_cast exact push_cast exact


refine suffices rw exact rw push_cast rw num_div_den] all_goals


rcases have obtain refine rcases refine push_cast exact choose have let have intro have simp rwa exact have intro suffices refine rw exact intro replace replace have have rcases refine simpa let refine refine obtain refine replace replace have refine rwa exact mk_le_of_forall_le let le_trans


let have have have refine rcases refine refine rw exact rcases refine refine rw exact


refine have obtain exact refine obtain refine exact_mod_cast refine have rw obtain refine refine rintro suffices exact exact refine norm_cast


obtain contrapose refine intro refine rw norm_cast rw rw norm_cast lia use calc


intro induction apply rw rintro obtain apply rw refine have rwa


rcases simp clear induction zero succ calc a gcongr norm_num exact


refine rw obtain constructor all_goals rintro apply exact_mod_cast exact rw have have exact_mod_cast


refine have rw refine contrapose exact simpa


ENNReal.HolderConjugate.conjExponent

have rw refine rw obtain simp obtain simp calc rw rw simp


have simpa suffices refine rwa rw rw rw exact


obtain use rw intro rw suffices intro exact


obtain obtain use suffices exact exact obtain use simpa


ext rw constructor such and intro rw obtain have contrapose simp have obtain refine rw simpa have rw rw convert abel have lt_of_lt_of_le rw exact rw rw intro rw rw exact


apply apply intro unfold suffices intro rw exact rw intro rw suffices intro have exact contrapose obtain exact


intro have have apply rw obtain have simpa exact


rw apply apply suffices intro suffices simpa rw simp_rw suffices intro have h contrapose obtain exact


obtain rw obtain rw exact by_cases exact rw


constructor rintro rcases exact exact rintro exacts


constructor rintro simp intro choose refine ext constructor aesop exact


induction zero obtain rw simp succ obtain subst have apply simp obtain rw simp right apply rwa


induction zero succ rw cases none some obtain simpa


induction zero succ rw let simp rw intro simp intro have rw simp


apply dsimp dsimp cases trivial rw dsimp exact


apply intro exact cases cases cases refine refine exact exact


have generalize apply intro cases nil intro apply simpa cons intro have rcases rw exact obtain rcases simp exact


apply intro exact cases cases refine exact


apply eq_of_bisim intro exact s, cases rw exact cases simp simpa


apply intro exact cases cases cases nil cons obtain refine obtain simpa exact refine


cases zero succ cases nil cons simp convert generalize enat_to_nat lia


induction zero succ simp generalize cases simpa exact


apply intro have rw generalize cases nil cons


induction zero succ cases nil cons simp rcases exacts


intro simp obtain rcases by_cases simp simp_all rw apply


Stream'.Seq.Pairwise.cons

simp intro cases zero succ simp cases zero simp exact succ


Stream'.Seq.Pairwise.coind

simp intro obtain rw rw have generalize cases nil cons simp exact


have rw have exact simp intro obtain clear induction zero succ obtain exact


have induction zero succ simp generalize cases nil cons simp obtain simpa by_cases simp simp by_contra have intro simp contradiction specialize generalize cases nil cons obtain apply_fun simp generalize enat_to_nat lia


apply intro exact cases cases obtain simpa exact refine


apply intro exact cases cases obtain simp cases exact refine exact refine


obtain simp rw simp rw generalize rcases induction nil cons induction nil cons obtain cases obtain


dsimp cases contradiction apply funext induction zero succ


dsimp rcases injection rw obtain apply dsimp rw exact contradiction


Computation.corec

refine rw change revert induction zero change rcases exact unfold succ rw exact


dsimp rw dsimp rcases dsimp apply dsimp rw dsimp


apply apply dsimp intro r⟩ suffices have refine constructor rw rw rw assumption rw exact rw exact simp_all exact


apply exact have revert simp apply apply apply


induction zero succ induction pure think rw rfl obtain cases contradiction have contradiction rw rfl


apply intro simp rcases simp rcases simp


apply intro induction pure simp induction pure think think exact


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


induction zero succ induction pure think simp exact have contradiction simp exact simp let rw exact


Computation.LiftRelRec.lem

revert refine intro have simp simp simp induction pure think


dsimp rcases apply funext induction zero succ contradiction


dsimp rcases contradiction obtain injections rw apply dsimp rw rw exact


Stream'.Seq.corec

refine rw change revert induction zero change rcases rfl dsimp dsimp revert rfl obtain contradiction succ rw exact


dsimp rw dsimp rcases obtain apply apply dsimp rw dsimp


apply apply dsimp intro exact suffices this have cases intro constructor rfl assumption intro rw exact intro rw exact simp exact


let apply intro simp rcases cases rcases cases grind


obtain induction zero have apply unfold rw rfl rw apply succ cases nil cons have rw apply


have intro obtain have apply simp rw rw exact intro revert apply intro apply induction nil cons simp rcases rw simp split obtain simp rw exact intro have induction nil cons simp rcases rw revert split simp simp rintro simp rcases a contradiction have grind rcases exact have destruct_eq_think simp rw rw refine have rcases


suffices c from let this intro rcases exact have rcases have apply rw rw simp rw infer_instance have destruct_eq_think simp rw rw refine apply simp rcases exact rcases have apply rw rw simp rw infer_instance have destruct_eq_think simp rw rw refine have intro apply rw rcases grind have dsimp rw rfl rw cases


suffices from let let intro rcases exact exact have induction intro assumption simp revert cases intro simp rcases exact rcases refine rw apply intro rcases rcases rw refine rw exact obtain obtain exact intro apply simp revert rcases intro rw rcases exact rcases exact let let obtain obtain exact let refine rw exact simp rcases rw refine rw apply exact let refine rw exact


refine eq_of_bisim intro exact have simp induction nil cons simp rw cases simp cases simp rw rcases simp simp induction


Computation.parallelRec

let have rw refine funext dsimp rw exact have rw have rw haveI rcases have rcases rw cases dsimp cases rcases rcases rw rcases injection constructor rwa rwa obtain apply


refine s.eq_empty_or_nonempty.elim rw exact


refine obtain rw obtain refine rintro rintro rw rw


refine obtain rw obtain refine rintro rintro rintro rw rw


induction zero succ obtain simp have obtain exact top


obtain rw obtain obtain have rw exact obtain refine rw


classical obtain simp exact obtain have rwa encard_diff_singleton_add_one obtain simp use rw simp not_forall, refine rintro assumption exact exact termination_by


let suffices rw exact ext simp refine obtain use


set have constructor rintro simp exact rintro obtain simp exact simp_rw exact


refine have simp_rw refine simp_rw simp exact


classical have rw obtain simp refine simp simp


rcases simp let rw add_le_add_iff_left] replace refine rw obtain simp suffices intro by_cases rw simp intro simpa congrArg


obtain exact classical rw obtain use simp


classical by_cases have rw obtain rw simp


classical refine simp intro suffices exact


induction basic cases exact exact univ h2 rcases exact exact exact exact ext constructor


constructor rintro refine rwa rintro rcases rw haveI rcases exact rcases refine rwa


rw have rintro exact choose have rintro have refine rw exact simp by_contra exact exact


wlog exact rcases clear induction zero cases zero succ m have have simp_all succ rw cases


refine obtain simp intro by_cases exact obtain refine rw exact


rw refine rintro by_cases intro rw exact obtain suffices simp_rw apply symm refine rw exact


Set.Countable.finiteExhaustion

apply by_cases obtain refine exact grind simp refine simp


haveI choose set set refine convert rw exact


Set.Finite.iUnion

suffices refine by_cases exact rw contradiction


induction empty cons simp rcases rcases exact


refine intro obtain exact rintro rintro exacts


refine rintro rw exact have choose rw use rw exact


obtain refine rintro exact rintro obtain grind


constructor rcases exact intro haveI exact rintro exact


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


simp apply constructor all_goals intro simp_all aesop


ext obtain refine rintro rwa refine grind


ext constructor intro by_cases right refine grind grind


constructor intro apply rw rw rintro rfl


ext constructor rintro exact rintro exact


ext rw constructor rintro rw grind grind


constructor rw rintro simp simp rintro simp


ext rintro refine exact rintro obtain refine exact


ext obtain have refine intro simp obtain rwa have simpa rw


classical apply simp intro simp rcases refine rw exact


inhabit refine simp choose refine suffices rw apply replace apply simp


refine induction nil cons rcases rcases exact


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


induction zero succ rw ext have simp obtain by_cases exact exact


induction zero succ rw have rw simp_rw refine rw simp


induction zero succ classical rw refine split_ifs


induction zero succ classical rw split_ifs


refine by_contra have disjoint_memPartition refine rw exact


rintro rcases exact have rw induction exact


by_contra have hs have ht obtain obtain refine exact


constructor rcases refine rcases apply exact rintro exact


refine suffices refine rw exact refine rintro exact


constructor intro exact intro rcases rcases rcases exact


Set.PairwiseDisjoint.biUnion

rintro simp_rw obtain obtain obtain exact exact


rintro rw obtain refine convert convert refine convert convert


rcases simp have refine have rwa have rwa intro simp exact


constructor intro have rw rw snd_image_prod grind


symm rcases simp_rw rintro exact rw rw simp_rw


ext constructor rintro exact obtain rintro exact


ext simp constructor rintro rintro rintro rw exact rintro rw exact


ext refine constructor rintro simpa rintro by_cases


classical ext simp constructor rintro exact rintro refine simpa


ext refine convert simp obtain simpa rw exact


obtain obtain have rw aesop exact invFun left_inv right_inv


refine obtain replace rw exact obtain exact


ext simp constructor rintro exact rintro exact


ext simp constructor rcases refine rwa rintro obtain rwa


subst obtain obtain rcases rw have cases rfl have cases rfl have conv_lhs


ext constructor intro rwa intro obtain rwa


Setoid.quotientEquivClasses

let have rw exact apply constructor intro induction induction simp apply change rw exact rw intro exact


intro suffices apply simpa apply contrapose exact


set have refine rw have refine simp rintro exact rw exact


refine rintro exact simp obtain refine simp simpa


obtain ext unfold obtain obtain simp simp rw rintro injection rw exact exact


constructor rintro exact exact obtain dsimp rintro exact exact


constructor rintro exact obtain obtain rintro exact


funext induction zero succ unfold rw rw exact


ext induction zero succ n have rw injection


constructor rcases rw rintro exact refine refine rw rintro exact rintro


refine constructor rintro exact cases exact rfl rfl exact


constructor obtain rw rintro exact refine rintro exact rintro exact exact rw rintro exact rintro exact exact exact exact


refine any_goals rintro cases exact simp rfl exact


try with_reducible_and_instances rfl try rfl exact


obtain have apply_fun rw exact use apply exact


obtain simp unfold split_ifs obtain exact refine refine refine


rw rintro simp_rw obtain replace obtain have have ext rw rintro rw simp exact


ext simp constructor rintro rw exact rintro rw exact


ext induction simp constructor rintro rw exact rintro rw exact


refine rfl have change insert rw fs simpa


refine exact simp refine refine exacts simpa simpa


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


List.Vector.inductionOn

induction zero rcases exact succ rcases cases exact


induction zero rcases rcases exact succ rcases cases rcases cases apply apply


induction zero rcases rcases rcases exact succ rcases cases rcases cases rcases cases apply apply


clear induction nil cons rw cases simp simp


refine intro rw simp cases none some obtain simp


refine intro exact c, induction pure think


unfold rcases rcases rcases have contradiction exact


apply intro apply cases contradiction assumption apply apply intro injection


obtain change constructor apply intro injections apply


generalize revert apply have simp obtain rw dsimp have rw refine rcases rw apply exact simp


intro induction exact exact apply rw cases rfl


induction rcases rcases injection injection obtain exact have rw exact


apply intro rcases exists simp rw apply obtain exists simpa intro obtain exists simp apply


refine c1 none some some c2 none some some intro induction refine refine


suffices from intro induction have substs simp rcases simp rcases simp exact induction have apply simp exact apply replace rcases exact simp apply


apply intro obtain rw induction exact exact


apply intro induction induction refine exact


apply intro exact induction induction exact refine exact exact refine


refine c1 none some some c2 none some some intro induction nil cons think


suffices intro rcases rw obtain rcases rcases apply cases cases cases cases obtain obtain rw exact


apply dsimp apply intro rcases trivial cases cases cases obtain obtain exact


obtain induction intro exact let let none, simp exact some simp exact let let let none, have rw apply apply let refine simp apply simp apply apply exact some simp refine simp apply simp apply apply apply rw exact


refine intro apply exact clear have induction exact


refine intro apply liftRel_rec c1 rintro induction nil induction nil simp induction nil cons simp refine think simp refine cons think cons think


refine intro apply liftRel_rec c1 c2 intro exact clear induction nil induction nil simp induction nil cons think cons think cons think


rcases simp change change simp norm_cast split_ifs rw congr rfl


rcases exact change cases rw subst subsingleton rw exact exact


ZMod.ringEquivCongr

rcases exact exfalso exact exfalso exact exact finCongr h map_mul dsimp ext rw map_add dsimp ext rw


split_ifs rw cases dsimp rw dsimp rw rw rwa exact


constructor rintro refine rw rintro rw add_zero,


rcases dsimp calc calc a push_cast rw rfl


constructor obtain simpa simp simpa rintro infer_instance


rw cases rw exact conv_lhs constructor rintro rcases rw rcases exact cases right rwa refine rw apply simp rintro rw apply rw


obtain by_cases obtain rw apply apply apply


induction zero succ ih have obtain by_cases cases simp exact rw


rw obtain rw subst obtain rw apply rw refine rw refine rw


ext simp conv refine simpa obtain simp obtain exact


rw split simp simp split rw rw rw have lia


suffices intro have refine have simp intro let use apply intro by_cases have rw rcases have rw exact exact have have rw contradiction


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


rcases simp by_cases dsimp rw apply intro rw exacts rw exact