module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.CategoryTheory.Triangulated.Opposite.Functor | {
"line": 121,
"column": 32
} | {
"line": 121,
"column": 44
} | [
{
"pp": "case e_a.e_a.e_a\nC : Type u_1\nD : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_2, u_2} D\ninst✝² : HasShift C ℤ\ninst✝¹ : HasShift D ℤ\nF : C ⥤ D\ninst✝ : F.CommShift ℤ\nX : Cᵒᵖ\nn : ℤ\n⊢ (shiftFunctorCompIsoId D (-n) n ⋯).hom.app (F.obj (unop X)) =\n (shiftFunctor D n).map\n ... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Triangulated.Opposite.Functor | {
"line": 134,
"column": 18
} | {
"line": 134,
"column": 30
} | [
{
"pp": "C : Type u_1\nD : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_2, u_2} D\ninst✝² : HasShift C ℤ\ninst✝¹ : HasShift D ℤ\nF : C ⥤ D\ninst✝ : F.CommShift ℤ\nX : Cᵒᵖ\nn : ℤ\n⊢ F.map\n (((opShiftFunctorEquivalence C n).unitIso.inv.app X).unop ≫\n ((opShiftFunctorEquivalence C n... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Triangulated.Opposite.Functor | {
"line": 146,
"column": 2
} | {
"line": 150,
"column": 84
} | [
{
"pp": "C : Type u_1\nD : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_2, u_2} D\ninst✝² : HasShift C ℤ\ninst✝¹ : HasShift D ℤ\nF : C ⥤ D\ninst✝ : F.CommShift ℤ\nX : Cᵒᵖ\nn : ℤ\n⊢ F.map ((opShiftFunctorEquivalence C n).counitIso.hom.app X).unop =\n ((opShiftFunctorEquivalence D n).counitIs... | apply Quiver.Hom.op_inj
dsimp [opShiftFunctorEquivalence]
rw [assoc, F.op_commShiftIso_hom_app_assoc _ _ _ (add_neg_cancel n), map_comp,
map_shiftFunctorCompIsoId_inv_app_assoc, op_comp, op_comp_assoc, op_comp_assoc,
NatTrans.naturality_assoc, op_map, Iso.inv_hom_id_app_assoc, Quiver.Hom.unop_op] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Triangulated.Opposite.Functor | {
"line": 146,
"column": 2
} | {
"line": 150,
"column": 84
} | [
{
"pp": "C : Type u_1\nD : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_2, u_2} D\ninst✝² : HasShift C ℤ\ninst✝¹ : HasShift D ℤ\nF : C ⥤ D\ninst✝ : F.CommShift ℤ\nX : Cᵒᵖ\nn : ℤ\n⊢ F.map ((opShiftFunctorEquivalence C n).counitIso.hom.app X).unop =\n ((opShiftFunctorEquivalence D n).counitIs... | apply Quiver.Hom.op_inj
dsimp [opShiftFunctorEquivalence]
rw [assoc, F.op_commShiftIso_hom_app_assoc _ _ _ (add_neg_cancel n), map_comp,
map_shiftFunctorCompIsoId_inv_app_assoc, op_comp, op_comp_assoc, op_comp_assoc,
NatTrans.naturality_assoc, op_map, Iso.inv_hom_id_app_assoc, Quiver.Hom.unop_op] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Triangulated.Opposite.Functor | {
"line": 160,
"column": 18
} | {
"line": 160,
"column": 30
} | [
{
"pp": "C : Type u_1\nD : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_2, u_2} D\ninst✝² : HasShift C ℤ\ninst✝¹ : HasShift D ℤ\nF : C ⥤ D\ninst✝ : F.CommShift ℤ\nX : Cᵒᵖ\nn : ℤ\n⊢ F.map\n (((opShiftFunctorEquivalence C n).counitIso.hom.app X).unop ≫\n ((opShiftFunctorEquivalence C... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Triangulated.LocalizingSubcategory | {
"line": 144,
"column": 4
} | {
"line": 144,
"column": 64
} | [
{
"pp": "case refine_2\nC : Type u_1\ninst✝⁸ : Category.{v_1, u_1} C\nA B : ObjectProperty C\ninst✝⁷ : HasZeroObject C\ninst✝⁶ : HasShift C ℤ\ninst✝⁵ : Preadditive C\ninst✝⁴ : ∀ (n : ℤ), (shiftFunctor C n).Additive\ninst✝³ : Pretriangulated C\ninst✝² : A.IsTriangulated\ninst✝¹ : B.IsTriangulated\ninst✝ : B.IsCl... | exact ⟨_, s'.op, b.op, hZ', trW_of_unop _ hs', by cat_disch⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | {
"line": 228,
"column": 4
} | {
"line": 228,
"column": 24
} | [
{
"pp": "C : Type u\ninst✝⁵ : Category.{v, u} C\ninst✝⁴ : Preadditive C\ninst✝³ : HasZeroObject C\ninst✝² : HasShift C ℤ\ninst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive\ninst✝ : Pretriangulated C\nt : TStructure C\nn : ℤ\nx✝³ x✝² : C\nx✝¹ x✝ : x✝³ ⟶ x✝²\n⊢ Triangle.π₁.map ((TruncAux.triangleFunctor t n).map (x... | rw [Functor.map_add] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | {
"line": 245,
"column": 4
} | {
"line": 245,
"column": 24
} | [
{
"pp": "C : Type u\ninst✝⁵ : Category.{v, u} C\ninst✝⁴ : Preadditive C\ninst✝³ : HasZeroObject C\ninst✝² : HasShift C ℤ\ninst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive\ninst✝ : Pretriangulated C\nt : TStructure C\nn : ℤ\nx✝³ x✝² : C\nx✝¹ x✝ : x✝³ ⟶ x✝²\n⊢ Triangle.π₃.map ((TruncAux.triangleFunctor t n).map (x... | rw [Functor.map_add] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Combinatorics.Additive.AP.Three.Behrend | {
"line": 369,
"column": 6
} | {
"line": 369,
"column": 51
} | [
{
"pp": "N : ℕ\nhN₃ : 8 ≤ N\nhN₀ : 0 < ↑N\nthis : ↑(nValue N) ≤ 2 * √(log ↑N)\n⊢ log 2 * 2 ≤ √(log ↑N)",
"usedConstants": [
"Real",
"HMul.hMul",
"Behrend.log_two_mul_two_le_sqrt_log_eight",
"Nat.instAtLeastTwoHAddOfNat",
"instOfNatNat",
"Nat.cast",
"Real.log",
... | apply log_two_mul_two_le_sqrt_log_eight.trans | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Combinatorics.Enumerative.DoubleCounting | {
"line": 199,
"column": 17
} | {
"line": 199,
"column": 35
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\nr : α → β → Prop\ns : Finset α\nt : Finset β\nhs : ∀ a ∈ s, ∃ b ∈ t, r a b\nht : ∀ b ∈ t, {a | a ∈ s ∧ r a b}.Subsingleton\nb : β\nh : b ∈ t\n⊢ ∀ a ∈ bipartiteBelow r s b, ∀ b_1 ∈ bipartiteBelow r s b, a = b_1",
"usedConstants": [
"Eq.mpr",
"Finset",
"C... | mem_bipartiteBelow | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Combinatorics.Additive.FreimanHom | {
"line": 162,
"column": 4
} | {
"line": 164,
"column": 57
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝¹ : CommMonoid α\ninst✝ : CommMonoid β\nA : Set α\nB : Set β\nf : α → β\nn : ℕ\ng : β → α\nh : InvOn g f A B\nhf : IsMulFreimanHom n A B f\nhg : IsMulFreimanHom n B A g\ns t : Multiset α\nhsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A\nhtA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A\nhs : s.card = n\nh... | have : (map g (map f s)).prod = (map g (map f t)).prod := by
have := hf.mapsTo
apply hg.map_prod_eq_map_prod <;> simp_all [MapsTo] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Combinatorics.Additive.ApproximateSubgroup | {
"line": 194,
"column": 28
} | {
"line": 194,
"column": 63
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nA : Set G\nhA : IsApproximateSubgroup 1 A\nthis : A * A ⊆ A\nx✝ : G\nhx : x✝ ∈ A\n⊢ x✝⁻¹ ∈ A",
"usedConstants": [
"Eq.mpr",
"Real",
"DivInvOneMonoid.toInvOneClass",
"congrArg",
"InvolutiveInv.toInv",
"Set.inv_mem_inv",
"Group.... | rwa [← hA.inv_eq_self, inv_mem_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Combinatorics.Additive.ApproximateSubgroup | {
"line": 194,
"column": 28
} | {
"line": 194,
"column": 63
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nA : Set G\nhA : IsApproximateSubgroup 1 A\nthis : A * A ⊆ A\nx✝ : G\nhx : x✝ ∈ A\n⊢ x✝⁻¹ ∈ A",
"usedConstants": [
"Eq.mpr",
"Real",
"DivInvOneMonoid.toInvOneClass",
"congrArg",
"InvolutiveInv.toInv",
"Set.inv_mem_inv",
"Group.... | rwa [← hA.inv_eq_self, inv_mem_inv] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.Additive.ApproximateSubgroup | {
"line": 194,
"column": 28
} | {
"line": 194,
"column": 63
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nA : Set G\nhA : IsApproximateSubgroup 1 A\nthis : A * A ⊆ A\nx✝ : G\nhx : x✝ ∈ A\n⊢ x✝⁻¹ ∈ A",
"usedConstants": [
"Eq.mpr",
"Real",
"DivInvOneMonoid.toInvOneClass",
"congrArg",
"InvolutiveInv.toInv",
"Set.inv_mem_inv",
"Group.... | rwa [← hA.inv_eq_self, inv_mem_inv] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Additive.PluenneckeRuzsa | {
"line": 230,
"column": 49
} | {
"line": 230,
"column": 73
} | [
{
"pp": "G : Type u_1\ninst✝¹ : DecidableEq G\ninst✝ : CommGroup G\nA B : Finset G\nhAB : ∀ A' ⊆ A, #(A * B) * #A' ≤ #(A' * B) * #A\nhA : A.Nonempty\nn : ℕ\nih : ↑(#(A * B ^ n)) ≤ (↑(#(A * B)) / ↑(#A)) ^ n * ↑(#A)\n⊢ ↑(#(A * B)) * ((↑(#(A * B)) / ↑(#A)) ^ n * ↑(#A)) = (↑(#(A * B)) / ↑(#A)) ^ (n + 1) * ↑(#A) * ↑... | by simp [field, pow_add] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.Additive.PluenneckeRuzsa | {
"line": 247,
"column": 39
} | {
"line": 247,
"column": 60
} | [
{
"pp": "G : Type u_1\ninst✝¹ : DecidableEq G\ninst✝ : CommGroup G\nA : Finset G\nhA : A.Nonempty\nB : Finset G\nm n : ℕ\nhA' : A ∈ A.powerset.erase ∅\nC : Finset G\nhCmin : ∀ x' ∈ A.powerset.erase ∅, ↑(#(C * B)) / ↑(#C) ≤ ↑(#(x' * B)) / ↑(#x')\nhC : C.Nonempty\nhCA : C ⊆ A\n⊢ ↑(#(B ^ m * C)) * ↑(#(B ^ n * C)) ... | by simp_rw [mul_comm] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.Additive.Convolution | {
"line": 118,
"column": 6
} | {
"line": 118,
"column": 25
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Group G\ninst✝ : DecidableEq G\nA B : Finset G\ns x : G\n⊢ A.convolution (B <• s) x = A.convolution B⁻¹⁻¹ (x * s⁻¹)",
"usedConstants": [
"Eq.mpr",
"instHSMul",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Finset.divisionMonoid",
"Monoid.t... | ← inv_inv (B <• s), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Partition.Equipartition | {
"line": 72,
"column": 2
} | {
"line": 72,
"column": 43
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : Finset α\nP : Finpartition s\nhP : P.IsEquipartition\nht : t ∈ P.parts\n⊢ #t ≤ (∑ i ∈ P.parts, #i) / #P.parts + 1",
"usedConstants": [
"Finset.EquitableOn.le_add_one",
"Finset",
"Finpartition.parts",
"Finset.instLattice",
"Fin... | exact Finset.EquitableOn.le_add_one hP ht | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Combinatorics.SimpleGraph.Density | {
"line": 84,
"column": 2
} | {
"line": 84,
"column": 20
} | [
{
"pp": "α : Type u_4\nβ : Type u_5\nr : α → β → Prop\ninst✝ : (a : α) → DecidablePred (r a)\ns s' : Finset α\nhs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'\nt : Finset β\na✝ : α × β\nhx : a✝.1 ∈ s ∧ a✝.2 ∈ t ∧ r a✝.1 a✝.2\nhy : a✝.1 ∈ s' ∧ a✝.2 ∈ t ∧ r a✝.1 a✝.2\n⊢ False",
"usedConstants": [
"Finset",
"Member... | exact hs hx.1 hy.1 | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.Partition.Finpartition | {
"line": 524,
"column": 66
} | {
"line": 533,
"column": 93
} | [
{
"pp": "α : Type u_1\ninst✝³ : Lattice α\ninst✝² : OrderBot α\ninst✝¹ : IsModularLattice α\ninst✝ : DecidableEq α\na : α\nP : Finpartition a\nQ : (i : α) → i ∈ P.parts → Finpartition i\n⊢ #(P.bind Q).parts = ∑ A ∈ P.parts.attach, #(Q ↑A ⋯).parts",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"... | by
apply card_biUnion
rintro ⟨b, hb⟩ - ⟨c, hc⟩ - hbc
rw [Function.onFun, Finset.disjoint_left]
rintro d hdb hdc
rw [Ne, Subtype.mk_eq_mk] at hbc
exact
(Q b hb).ne_bot hdb
(eq_bot_iff.2 <|
(le_inf ((Q b hb).le hdb) <| (Q c hc).le hdc).trans <| (P.disjoint hb hc hbc).le_bot) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.SimpleGraph.Density | {
"line": 345,
"column": 2
} | {
"line": 345,
"column": 69
} | [
{
"pp": "α : Type u_4\nG : SimpleGraph α\ninst✝¹ : DecidableRel G.Adj\ns t : Finset α\ninst✝ : DecidableEq α\nhs : s.Nonempty\nht : t.Nonempty\nh : Disjoint s t\n⊢ G.edgeDensity s t + Gᶜ.edgeDensity s t = 1",
"usedConstants": [
"Rat.instOfNat",
"Eq.mpr",
"SimpleGraph.edgeDensity_def",
... | rw [edgeDensity_def, edgeDensity_def, ← add_div, div_eq_one_iff_eq] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Combinatorics.SimpleGraph.DeleteEdges | {
"line": 206,
"column": 11
} | {
"line": 206,
"column": 34
} | [
{
"pp": "V : Type u_1\ninst✝² : Fintype V\ninst✝¹ : DecidableEq V\nG : SimpleGraph V\ninst✝ : DecidableRel G.Adj\nx : V\nhx : {x}.toFinset ⊆ G.support.toFinset\n⊢ Fintype.card ↑(G.deleteIncidenceSet x).support ≤ Fintype.card ↑G.support - 1",
"usedConstants": [
"SimpleGraph.instDecidableRelAdjDeleteInc... | ← Set.card_singleton x, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Combinatorics.SimpleGraph.Copy | {
"line": 618,
"column": 4
} | {
"line": 618,
"column": 31
} | [
{
"pp": "V : Type u_1\nW : Type u_2\nG : SimpleGraph V\nH : SimpleGraph W\nhH : H ≠ ⊥\nG' : (G \\ fromEdgeSet (⋃ G', ⋃ (hG' : Nonempty (H ≃g G'.coe)), {⋯.some})).Subgraph\nhHG' : Nonempty (H ≃g G'.coe)\n⊢ (Sym2.map ⇑(Hom.ofLE ⋯) '' G'.edgeSet).Nonempty",
"usedConstants": [
"Sym2.map",
"SimpleGra... | exact (aux hH hHG').image _ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Combinatorics.SimpleGraph.Operations | {
"line": 215,
"column": 2
} | {
"line": 215,
"column": 60
} | [
{
"pp": "V : Type u_1\nG : SimpleGraph V\ns t : V\ninst✝² : Fintype V\ninst✝¹ : DecidableRel G.Adj\ninst✝ : Fintype ↑(G ⊔ edge s t).edgeSet\nhn : ¬G.Adj s t\nh : s ≠ t\nthis : DecidableEq V := Classical.decEq V\n⊢ (G ⊔ edge s t).edgeFinset = cons s(s, t) G.edgeFinset ⋯",
"usedConstants": [
"Eq.mpr",
... | rw [edgeFinset_sup, cons_eq_insert, insert_eq, union_comm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Combinatorics.SimpleGraph.Walk.Maps | {
"line": 121,
"column": 6
} | {
"line": 121,
"column": 43
} | [
{
"pp": "case cons.cons\nV : Type u\nV' : Type v\nG : SimpleGraph V\nG' : SimpleGraph V'\nf : G →g G'\nhinj : Function.Injective ⇑f\nu v u✝ v✝¹ w✝ : V\nh✝¹ : G.Adj u✝ v✝¹\np✝¹ : G.Walk v✝¹ w✝\nih : ∀ ⦃p' : G.Walk v✝¹ w✝⦄, Walk.map f p✝¹ = Walk.map f p' → p✝¹ = p'\nv✝ : V\nh✝ : G.Adj u✝ v✝\np✝ : G.Walk v✝ w✝\nh ... | simp only [map_cons, cons.injEq] at h | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Combinatorics.SimpleGraph.Walk.Basic | {
"line": 424,
"column": 11
} | {
"line": 424,
"column": 23
} | [
{
"pp": "case nil\nV : Type u\nG : SimpleGraph V\nu v w u✝ : V\nhnil : ¬nil.Nil\n⊢ w ∈ nil.support ↔ ∃ e ∈ nil.edges, w ∈ e",
"usedConstants": [
"False",
"congrArg",
"False.elim",
"SimpleGraph.Walk.support",
"Membership.mem",
"Exists",
"Eq.mp",
"not_true_eq_fa... | simp at hnil | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Combinatorics.SimpleGraph.Walk.Basic | {
"line": 424,
"column": 11
} | {
"line": 424,
"column": 23
} | [
{
"pp": "case nil\nV : Type u\nG : SimpleGraph V\nu v w u✝ : V\nhnil : ¬nil.Nil\n⊢ w ∈ nil.support ↔ ∃ e ∈ nil.edges, w ∈ e",
"usedConstants": [
"False",
"congrArg",
"False.elim",
"SimpleGraph.Walk.support",
"Membership.mem",
"Exists",
"Eq.mp",
"not_true_eq_fa... | simp at hnil | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.SimpleGraph.Walk.Basic | {
"line": 424,
"column": 11
} | {
"line": 424,
"column": 23
} | [
{
"pp": "case nil\nV : Type u\nG : SimpleGraph V\nu v w u✝ : V\nhnil : ¬nil.Nil\n⊢ w ∈ nil.support ↔ ∃ e ∈ nil.edges, w ∈ e",
"usedConstants": [
"False",
"congrArg",
"False.elim",
"SimpleGraph.Walk.support",
"Membership.mem",
"Exists",
"Eq.mp",
"not_true_eq_fa... | simp at hnil | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.SimpleGraph.Walk.Operations | {
"line": 314,
"column": 6
} | {
"line": 314,
"column": 46
} | [
{
"pp": "case cons.nil\nV : Type u\nG : SimpleGraph V\nu v v' w : V\nh' : G.Adj v' w\nv✝ w✝ : V\np✝ : G.Walk v✝ w✝\nih : ∀ {h : G.Adj w✝ w} {p' : G.Walk v✝ v'}, p✝.concat h = p'.concat h' → ∃ (hv : w✝ = v'), p✝.copy ⋯ hv = p'\nh : G.Adj w✝ w\nh✝ : G.Adj v' v✝\nhe : cons h✝ (p✝.concat h) = nil.concat h'\n⊢ ∃ (hv... | simp only [concat_nil, cons.injEq] at he | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Combinatorics.SimpleGraph.Walk.Operations | {
"line": 394,
"column": 85
} | {
"line": 395,
"column": 54
} | [
{
"pp": "V : Type u\nG : SimpleGraph V\nu v w : V\np : G.Walk u v\np' : G.Walk v w\n⊢ ↑(p.append p').support = {u} + ↑p.support.tail + ↑p'.support.tail",
"usedConstants": [
"Eq.mpr",
"Multiset.coe_add",
"congrArg",
"SimpleGraph.Walk.support",
"Multiset",
"id",
"List... | by
rw [support_append, ← Multiset.coe_add, coe_support] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | {
"line": 123,
"column": 39
} | {
"line": 123,
"column": 73
} | [
{
"pp": "case refine_2.refine_3.h\nV : Type u_1\nG : SimpleGraph V\nv w v' w' : V\np₁ : G.Walk v w\np₂ : G.Walk v' w'\nx✝ : p₁.support <:+: p₂.support\ns t : List V\nh : s ++ p₁.support ++ t = p₂.support\nthis : s.length + p₁.length ≤ p₂.length\n⊢ s ++ p₁.support ++ t =\n List.take (s.length + 1) s ++ List.t... | List.drop_eq_nil_of_le (by grind), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | {
"line": 114,
"column": 4
} | {
"line": 124,
"column": 36
} | [
{
"pp": "case refine_2\nV : Type u_1\nG : SimpleGraph V\nv w v' w' : V\np₁ : G.Walk v w\np₂ : G.Walk v' w'\nx✝ : p₁.support <:+: p₂.support\ns t : List V\nh : s ++ p₁.support ++ t = p₂.support\n⊢ p₁.IsSubwalk p₂",
"usedConstants": [
"List.head",
"Nat.le_add_right._simp_1",
"Eq.mpr",
... | have : (s.length + p₁.length) ≤ p₂.length := by grind [_=_ length_support]
refine ⟨p₂.take s.length |>.copy rfl ?_, p₂.drop (s.length + p₁.length) |>.copy ?_ rfl, ?_⟩
· simp [p₂.getVert_eq_support_getElem (by lia : s.length ≤ p₂.length), ← h,
List.getElem_zero]
· simp [p₂.getVert_eq_support_getElem ... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | {
"line": 114,
"column": 4
} | {
"line": 124,
"column": 36
} | [
{
"pp": "case refine_2\nV : Type u_1\nG : SimpleGraph V\nv w v' w' : V\np₁ : G.Walk v w\np₂ : G.Walk v' w'\nx✝ : p₁.support <:+: p₂.support\ns t : List V\nh : s ++ p₁.support ++ t = p₂.support\n⊢ p₁.IsSubwalk p₂",
"usedConstants": [
"List.head",
"Nat.le_add_right._simp_1",
"Eq.mpr",
... | have : (s.length + p₁.length) ≤ p₂.length := by grind [_=_ length_support]
refine ⟨p₂.take s.length |>.copy rfl ?_, p₂.drop (s.length + p₁.length) |>.copy ?_ rfl, ?_⟩
· simp [p₂.getVert_eq_support_getElem (by lia : s.length ≤ p₂.length), ← h,
List.getElem_zero]
· simp [p₂.getVert_eq_support_getElem ... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | {
"line": 55,
"column": 63
} | {
"line": 55,
"column": 84
} | [
{
"pp": "case nil\nV : Type u\nG : SimpleGraph V\nv : V\ninst✝ : DecidableEq V\n⊢ nil.takeUntil v ⋯ = nil",
"usedConstants": [
"SimpleGraph.Walk",
"SimpleGraph.Walk.nil",
"eq_self",
"of_eq_true",
"Eq"
]
}
] | simp [Walk.takeUntil] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | {
"line": 55,
"column": 63
} | {
"line": 55,
"column": 84
} | [
{
"pp": "case cons\nV : Type u\nG : SimpleGraph V\nv u : V\ninst✝ : DecidableEq V\nv✝ : V\nh✝ : G.Adj u v✝\np✝ : G.Walk v✝ v\n⊢ (cons h✝ p✝).takeUntil u ⋯ = nil",
"usedConstants": [
"dite_cond_eq_true",
"congrArg",
"SimpleGraph.Walk.start_mem_support",
"SimpleGraph.Walk",
"Eq.r... | simp [Walk.takeUntil] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Combinatorics.SimpleGraph.Walk.Operations | {
"line": 669,
"column": 4
} | {
"line": 670,
"column": 12
} | [
{
"pp": "case neg\nV : Type u\nG : SimpleGraph V\nu v : V\np : G.Walk u v\nn : ℕ\nh : p.length ≤ n\n⊢ List.take (n + 1) p.support ++ List.drop (min n p.length + 1) p.support = p.support",
"usedConstants": [
"Eq.mpr",
"congrArg",
"SimpleGraph.Walk.length",
"PartialOrder.toPreorder",
... | rw [Nat.min_eq_right h, ← length_support, List.drop_length]
simp [h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.SimpleGraph.Walk.Operations | {
"line": 669,
"column": 4
} | {
"line": 670,
"column": 12
} | [
{
"pp": "case neg\nV : Type u\nG : SimpleGraph V\nu v : V\np : G.Walk u v\nn : ℕ\nh : p.length ≤ n\n⊢ List.take (n + 1) p.support ++ List.drop (min n p.length + 1) p.support = p.support",
"usedConstants": [
"Eq.mpr",
"congrArg",
"SimpleGraph.Walk.length",
"PartialOrder.toPreorder",
... | rw [Nat.min_eq_right h, ← length_support, List.drop_length]
simp [h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.SimpleGraph.Walk.Operations | {
"line": 706,
"column": 6
} | {
"line": 706,
"column": 36
} | [
{
"pp": "case cons\nV : Type u\nG : SimpleGraph V\nt u v u✝ v✝ w✝ : V\nh✝ : G.Adj u✝ v✝\np✝ : G.Walk v✝ w✝\np_ih✝ : ∀ (h : G.Adj w✝ t), (p✝.concat h).dropLast = p✝.copy ⋯ ⋯\nh : G.Adj w✝ t\n⊢ cons h✝ ((p✝.concat h).dropLast.copy ⋯ ⋯) = (cons h✝ p✝).copy ⋯ ⋯",
"usedConstants": [
"congrArg",
"Simp... | simp [*, ← length_eq_zero_iff] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Combinatorics.SimpleGraph.Walk.Operations | {
"line": 706,
"column": 6
} | {
"line": 706,
"column": 36
} | [
{
"pp": "case cons.hp\nV : Type u\nG : SimpleGraph V\nt u v u✝ v✝ w✝ : V\nh✝ : G.Adj u✝ v✝\np✝ : G.Walk v✝ w✝\np_ih✝ : ∀ (h : G.Adj w✝ t), (p✝.concat h).dropLast = p✝.copy ⋯ ⋯\nh : G.Adj w✝ t\n⊢ ¬(p✝.concat h).Nil",
"usedConstants": [
"False",
"Nat.instOne",
"congrArg",
"SimpleGraph.... | simp [*, ← length_eq_zero_iff] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Combinatorics.SimpleGraph.Walk.Operations | {
"line": 717,
"column": 4
} | {
"line": 719,
"column": 22
} | [
{
"pp": "case cons\nV : Type u\nG : SimpleGraph V\nu v u✝ v✝ w✝ : V\nhadj : G.Adj u✝ v✝\np : G.Walk v✝ w✝\nhind : ∀ (hp : G.Adj p.penultimate w✝), p.dropLast.concat hp = p\nhp : G.Adj (cons hadj p).penultimate w✝\n⊢ (cons hadj p).dropLast.concat hp = cons hadj p",
"usedConstants": [
"congrArg",
... | cases p with
| nil => rfl
| _ => simp [hind] | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Combinatorics.SimpleGraph.Walk.Operations | {
"line": 717,
"column": 4
} | {
"line": 719,
"column": 22
} | [
{
"pp": "case cons\nV : Type u\nG : SimpleGraph V\nu v u✝ v✝ w✝ : V\nhadj : G.Adj u✝ v✝\np : G.Walk v✝ w✝\nhind : ∀ (hp : G.Adj p.penultimate w✝), p.dropLast.concat hp = p\nhp : G.Adj (cons hadj p).penultimate w✝\n⊢ (cons hadj p).dropLast.concat hp = cons hadj p",
"usedConstants": [
"congrArg",
... | cases p with
| nil => rfl
| _ => simp [hind] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.SimpleGraph.Walk.Operations | {
"line": 717,
"column": 4
} | {
"line": 719,
"column": 22
} | [
{
"pp": "case cons\nV : Type u\nG : SimpleGraph V\nu v u✝ v✝ w✝ : V\nhadj : G.Adj u✝ v✝\np : G.Walk v✝ w✝\nhind : ∀ (hp : G.Adj p.penultimate w✝), p.dropLast.concat hp = p\nhp : G.Adj (cons hadj p).penultimate w✝\n⊢ (cons hadj p).dropLast.concat hp = cons hadj p",
"usedConstants": [
"congrArg",
... | cases p with
| nil => rfl
| _ => simp [hind] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | {
"line": 166,
"column": 8
} | {
"line": 172,
"column": 18
} | [
{
"pp": "case neg\nV : Type u\nG : SimpleGraph V\ninst✝ : DecidableEq V\nu v w x u✝ v✝ w✝ : V\nha : G.Adj u✝ v✝\np' : G.Walk v✝ w✝\nih : ∀ (h : u ∈ p'.support), List.count s(u, x) (p'.takeUntil u h).edges ≤ 1\na✝ : List.Mem u p'.support\nh' : ¬u✝ = u\n⊢ List.count s(u, x) (cons ha (p'.takeUntil u ⋯)).edges ≤ 1"... | rw [edges_cons, List.count_cons]
split_ifs with h''
· simp only [beq_iff_eq, Sym2.eq, Sym2.rel_iff'] at h''
obtain ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ := h''
· exact (h' rfl).elim
· cases p' <;> simp!
· apply ih | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | {
"line": 166,
"column": 8
} | {
"line": 172,
"column": 18
} | [
{
"pp": "case neg\nV : Type u\nG : SimpleGraph V\ninst✝ : DecidableEq V\nu v w x u✝ v✝ w✝ : V\nha : G.Adj u✝ v✝\np' : G.Walk v✝ w✝\nih : ∀ (h : u ∈ p'.support), List.count s(u, x) (p'.takeUntil u h).edges ≤ 1\na✝ : List.Mem u p'.support\nh' : ¬u✝ = u\n⊢ List.count s(u, x) (cons ha (p'.takeUntil u ⋯)).edges ≤ 1"... | rw [edges_cons, List.count_cons]
split_ifs with h''
· simp only [beq_iff_eq, Sym2.eq, Sym2.rel_iff'] at h''
obtain ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ := h''
· exact (h' rfl).elim
· cases p' <;> simp!
· apply ih | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | {
"line": 286,
"column": 78
} | {
"line": 295,
"column": 5
} | [
{
"pp": "V : Type u\nG : SimpleGraph V\nv u : V\ninst✝ : DecidableEq V\np : G.Walk u v\nw x : V\nh : x ≠ w\nhw : w ∈ p.support\nhx : x ∈ (p.takeUntil w hw).support\n⊢ w ∉ (p.takeUntil x ⋯).support",
"usedConstants": [
"Eq.mpr",
"congrArg",
"SimpleGraph.Walk.takeUntil_takeUntil",
"Sim... | by
rw [← takeUntil_takeUntil p hw hx]
intro hw'
have h1 : (((p.takeUntil w hw).takeUntil x hx).takeUntil w hw').length
< ((p.takeUntil w hw).takeUntil x hx).length := by
exact length_takeUntil_lt _ h.symm
have h2 : ((p.takeUntil w hw).takeUntil x hx).length < (p.takeUntil w hw).length := by
exact ... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.SimpleGraph.Paths | {
"line": 304,
"column": 15
} | {
"line": 307,
"column": 5
} | [
{
"pp": "V : Type u\nG : SimpleGraph V\nu v : V\np : G.Walk u v\nh : G.Adj v u\nhc : (cons h p).IsCycle\n⊢ ¬p.Nil",
"usedConstants": [
"Eq.mpr",
"congrArg",
"SimpleGraph.Walk.length",
"Eq.rec",
"id",
"instOfNatNat",
"LE.le",
"instLENat",
"SimpleGraph.Wal... | by
have := Walk.length_cons _ _ ▸ Walk.IsCycle.three_le_length hc
rw [Walk.not_nil_iff_lt_length]
lia | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.SimpleGraph.Paths | {
"line": 317,
"column": 2
} | {
"line": 318,
"column": 86
} | [
{
"pp": "V : Type u\nG : SimpleGraph V\nu : V\np : G.Walk u u\nh : p.IsCycle\n⊢ p.reverse.IsCycle",
"usedConstants": [
"Eq.mpr",
"False",
"eq_false",
"congrArg",
"SimpleGraph.Walk.length",
"False.elim",
"SimpleGraph.Walk.IsCycle",
"SimpleGraph.Walk.support",
... | simp only [Walk.isCycle_def, nodup_tail_support_reverse] at h ⊢
exact ⟨h.1.reverse, fun h' ↦ h.2.1 (by simp_all [← Walk.length_eq_zero_iff]), h.2.2⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.SimpleGraph.Paths | {
"line": 317,
"column": 2
} | {
"line": 318,
"column": 86
} | [
{
"pp": "V : Type u\nG : SimpleGraph V\nu : V\np : G.Walk u u\nh : p.IsCycle\n⊢ p.reverse.IsCycle",
"usedConstants": [
"Eq.mpr",
"False",
"eq_false",
"congrArg",
"SimpleGraph.Walk.length",
"False.elim",
"SimpleGraph.Walk.IsCycle",
"SimpleGraph.Walk.support",
... | simp only [Walk.isCycle_def, nodup_tail_support_reverse] at h ⊢
exact ⟨h.1.reverse, fun h' ↦ h.2.1 (by simp_all [← Walk.length_eq_zero_iff]), h.2.2⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.SimpleGraph.Paths | {
"line": 365,
"column": 2
} | {
"line": 373,
"column": 5
} | [
{
"pp": "V : Type u\nG : SimpleGraph V\nN : Nonempty V\ninst✝ : Finite ↑G.edgeSet\n⊢ ∃ u v p, ∃ (_ : p.IsPath), ∀ (u' v' : V) (p' : G.Walk u' v'), p'.IsPath → p'.length ≤ p.length",
"usedConstants": [
"SimpleGraph.Walk.IsPath.isTrail",
"Fintype.ofFinite",
"congrArg",
"and_self",
... | have := Fintype.ofFinite G.edgeSet
let s := {n | ∃ (u v : V) (p : G.Walk u v), p.IsPath ∧ p.length = n}
have : s.Finite := Set.Finite.subset (Set.finite_le_nat G.edgeFinset.card)
fun n ⟨_, _, _, hp, hn⟩ ↦ hn ▸ hp.isTrail.length_le_card_edgeFinset
obtain ⟨x⟩ := N
obtain ⟨_, ⟨⟨u, v, p, hp, _⟩, hn⟩⟩ := this.ex... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.SimpleGraph.Paths | {
"line": 365,
"column": 2
} | {
"line": 373,
"column": 5
} | [
{
"pp": "V : Type u\nG : SimpleGraph V\nN : Nonempty V\ninst✝ : Finite ↑G.edgeSet\n⊢ ∃ u v p, ∃ (_ : p.IsPath), ∀ (u' v' : V) (p' : G.Walk u' v'), p'.IsPath → p'.length ≤ p.length",
"usedConstants": [
"SimpleGraph.Walk.IsPath.isTrail",
"Fintype.ofFinite",
"congrArg",
"and_self",
... | have := Fintype.ofFinite G.edgeSet
let s := {n | ∃ (u v : V) (p : G.Walk u v), p.IsPath ∧ p.length = n}
have : s.Finite := Set.Finite.subset (Set.finite_le_nat G.edgeFinset.card)
fun n ⟨_, _, _, hp, hn⟩ ↦ hn ▸ hp.isTrail.length_le_card_edgeFinset
obtain ⟨x⟩ := N
obtain ⟨_, ⟨⟨u, v, p, hp, _⟩, hn⟩⟩ := this.ex... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | {
"line": 140,
"column": 94
} | {
"line": 141,
"column": 93
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\n𝕜 : Type u_3\ninst✝⁵ : Field 𝕜\ninst✝⁴ : LinearOrder 𝕜\ninst✝³ : IsStrictOrderedRing 𝕜\nG H : SimpleGraph α\nε δ : 𝕜\ninst✝² : DecidableEq α\ninst✝¹ : Fintype α\ninst✝ : DecidableRel G.Adj\n⊢ ((↑(G.cliqueFinset 3)).Pairwise fun x y ↦ #(x ∩ y) ≤ 1) ↔ G.EdgeDisjointTriang... | by
simp only [coe_cliqueFinset, EdgeDisjointTriangles, Finset.card_le_one, ← coe_inter]; rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.SimpleGraph.Clique | {
"line": 133,
"column": 6
} | {
"line": 133,
"column": 23
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nG : SimpleGraph α\ns : Set α\nf : α ↪ β\n⊢ (SimpleGraph.map (⇑f) G).IsClique (⇑f '' s) ↔ G.IsClique s",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Exists",
"id",
"Function.Embedding",
"And",
"Iff",
"Set.Subsingleton",
... | isClique_map_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Combinatorics.SimpleGraph.Clique | {
"line": 136,
"column": 2
} | {
"line": 136,
"column": 73
} | [
{
"pp": "case inr\nα : Type u_1\nβ : Type u_2\nG : SimpleGraph α\ns : Set α\nf : α ↪ β\nhs : s.Nontrivial\n⊢ (s.Subsingleton ∨ ∃ s_1, G.IsClique s_1 ∧ ⇑f '' s_1 = ⇑f '' s) ↔ G.IsClique s",
"usedConstants": [
"congrArg",
"Exists",
"Set.image_eq_image",
"Function.Embedding",
"iff... | simp [or_iff_right hs.not_subsingleton, Set.image_eq_image f.injective] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Combinatorics.SimpleGraph.Paths | {
"line": 583,
"column": 2
} | {
"line": 587,
"column": 95
} | [
{
"pp": "V : Type u\nG : SimpleGraph V\nv w : V\ninst✝ : DecidableEq V\nc : G.Walk v v\nhc : c.IsCycle\nh : w ∈ c.support\n⊢ (c.takeUntil w h).IsPath",
"usedConstants": [
"congrArg",
"SimpleGraph.Walk.reverse_append",
"SimpleGraph.Walk.IsCycle",
"SimpleGraph.Walk.support",
"Sim... | by_cases hvw : v = w
· subst hvw
simp
rw [← isCycle_reverse, ← take_spec c h, reverse_append] at hc
exact (c.takeUntil w h).isPath_reverse_iff.mp (hc.isPath_of_append_right (not_nil_of_ne hvw)) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.SimpleGraph.Paths | {
"line": 583,
"column": 2
} | {
"line": 587,
"column": 95
} | [
{
"pp": "V : Type u\nG : SimpleGraph V\nv w : V\ninst✝ : DecidableEq V\nc : G.Walk v v\nhc : c.IsCycle\nh : w ∈ c.support\n⊢ (c.takeUntil w h).IsPath",
"usedConstants": [
"congrArg",
"SimpleGraph.Walk.reverse_append",
"SimpleGraph.Walk.IsCycle",
"SimpleGraph.Walk.support",
"Sim... | by_cases hvw : v = w
· subst hvw
simp
rw [← isCycle_reverse, ← take_spec c h, reverse_append] at hc
exact (c.takeUntil w h).isPath_reverse_iff.mp (hc.isPath_of_append_right (not_nil_of_ne hvw)) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.SimpleGraph.Paths | {
"line": 608,
"column": 2
} | {
"line": 608,
"column": 41
} | [
{
"pp": "V : Type u\nG : SimpleGraph V\nu v w : V\ninst✝ : DecidableEq V\np : G.Walk u v\nhp : p.IsPath\nhw : w ∈ p.support\nh : v ≠ w\nn : ℕ\nhn : p.getVert n = v\nhnl : n ≤ (p.takeUntil w hw).length\n⊢ False",
"usedConstants": [
"SimpleGraph.Walk.length",
"SimpleGraph.Walk.length_takeUntil_lt"... | have := p.length_takeUntil_lt hw h.symm | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | {
"line": 275,
"column": 6
} | {
"line": 275,
"column": 16
} | [
{
"pp": "α : Type u_1\n𝕜 : Type u_3\ninst✝⁵ : Field 𝕜\ninst✝⁴ : LinearOrder 𝕜\ninst✝³ : IsStrictOrderedRing 𝕜\nG : SimpleGraph α\nε : 𝕜\ninst✝² : Fintype α\ninst✝¹ : DecidableRel G.Adj\ninst✝ : Nonempty α\nh₀ : G.FarFromTriangleFree ε\nh₁ : G.CliqueFree 3\nthis : (fun H ↦ H.CliqueFree 3) (G.deleteEdges ↑∅)... | coe_empty, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | {
"line": 44,
"column": 2
} | {
"line": 44,
"column": 85
} | [
{
"pp": "α : Type u_1\nG : SimpleGraph α\ninst✝ : DecidableRel G.Adj\nε : ℝ\ns t : Finset α\n⊢ ↑(∑ a ∈ G.badVertices ε s t, #(map { toFun := fun x ↦ (a, x), inj' := ⋯ } ({y ∈ t | G.Adj a y}))) ≤\n ↑(#(G.badVertices ε s t)) * ↑(#t) * (↑(G.edgeDensity s t) - ε)",
"usedConstants": [
"NonUnitalNonAssoc... | simp_rw [Nat.cast_sum, card_map, ← nsmul_eq_mul, smul_mul_assoc, mul_comm (#t : ℝ)] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | {
"line": 109,
"column": 83
} | {
"line": 134,
"column": 7
} | [
{
"pp": "α : Type u_1\nG : SimpleGraph α\ninst✝ : DecidableRel G.Adj\nε : ℝ\ns t u : Finset α\ndst : 2 * ε ≤ ↑(G.edgeDensity s t)\nhst : G.IsUniform ε s t\ndsu : 2 * ε ≤ ↑(G.edgeDensity s u)\nusu : G.IsUniform ε s u\ndtu : 2 * ε ≤ ↑(G.edgeDensity t u)\nutu : G.IsUniform ε t u\n⊢ (1 - 2 * ε) * ε ^ 3 * ↑(#s) * ↑(... | by
classical
have h₁ : #(badVertices G ε s t) ≤ #s * ε := G.card_badVertices_le dst hst
have h₂ : #(badVertices G ε s u) ≤ #s * ε := G.card_badVertices_le dsu usu
let X' := s \ (badVertices G ε s t ∪ badVertices G ε s u)
have : X'.biUnion _ ⊆ (s ×ˢ t ×ˢ u).filter fun (a, b, c) ↦ G.Adj a b ∧ G.Adj a c ∧ G.Adj ... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.SimpleGraph.Triangle.Removal | {
"line": 55,
"column": 63
} | {
"line": 55,
"column": 84
} | [
{
"pp": "case hbc\nε : ℝ\nhε : 0 < ε\n⊢ triangleRemovalBound ε ≤ (2 * ↑⌈4 / ε⌉₊ ^ 3)⁻¹",
"usedConstants": [
"Real.instIsOrderedRing",
"SzemerediRegularity.bound",
"Real.partialOrder",
"Real",
"instHDiv",
"HMul.hMul",
"FloorRing.toFloorSemiring",
"Real.instInv"... | exact min_le_left _ _ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Combinatorics.SimpleGraph.Triangle.Removal | {
"line": 98,
"column": 78
} | {
"line": 99,
"column": 47
} | [
{
"pp": "α : Type u_1\ninst✝² : DecidableEq α\ninst✝¹ : Fintype α\nG : SimpleGraph α\ninst✝ : DecidableRel G.Adj\nP : Finpartition univ\nε : ℝ\nhε : 0 < ε\nhε₁ : ε ≤ 1\nhP₁ : P.IsEquipartition\nhP₃ : #P.parts ≤ bound (ε / 8) ⌈4 / ε⌉₊\nx y z : α\ns : Finset α\nhX : s ∈ P.parts\nY : Finset α\nhY : Y ∈ P.parts\nxX... | by
gcongr; exact triangleRemovalBound_le hε₁ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.Additive.Dissociation | {
"line": 66,
"column": 91
} | {
"line": 67,
"column": 31
} | [
{
"pp": "α : Type u_1\ninst✝ : CommGroup α\ns : Set α\n⊢ ¬MulDissociated s ↔ ∃ t, ↑t ⊆ s ∧ ∃ u, ↑u ⊆ s ∧ t ≠ u ∧ ∏ x ∈ t, x = ∏ x ∈ u, x",
"usedConstants": [
"_private.Mathlib.Combinatorics.Additive.Dissociation.0.not_mulDissociated._proof_1_1"
]
}
] | by
grind [MulDissociated, InjOn] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.Additive.Corner.Roth | {
"line": 58,
"column": 64
} | {
"line": 62,
"column": 32
} | [
{
"pp": "G : Type u_1\ninst✝² : AddCommGroup G\nA : Finset (G × G)\nε : ℝ\ninst✝¹ : Fintype G\ninst✝ : DecidableEq G\nhε : ε * ↑(Fintype.card G) ^ 2 ≤ ↑(#A)\n⊢ (graph (triangleIndices A)).FarFromTriangleFree (ε / 9)",
"usedConstants": [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"Eq.mpr",
"... | by
refine farFromTriangleFree _ ?_
simp_rw [card_triangleIndices, mul_comm_div, Nat.cast_pow, Nat.cast_add]
ring_nf
simpa only [mul_comm] using hε | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.LinearAlgebra.Projectivization.Basic | {
"line": 124,
"column": 9
} | {
"line": 124,
"column": 11
} | [
{
"pp": "case mpr\nK : Type u_1\nV : Type u_2\ninst✝² : DivisionRing K\ninst✝¹ : AddCommGroup V\ninst✝ : Module K V\nv w : V\nhv : v ≠ 0\nhw : w ≠ 0\na : K\nha : a • w = v\nc : a = 0\n⊢ 0 = v",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"instHSMul",
"congrArg",
"DistribMulA... | c, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.Projectivization.Basic | {
"line": 150,
"column": 2
} | {
"line": 150,
"column": 40
} | [
{
"pp": "K : Type u_1\nV : Type u_2\ninst✝² : DivisionRing K\ninst✝¹ : AddCommGroup V\ninst✝ : Module K V\nv : ℙ K V\n⊢ FiniteDimensional K ↥(mk K v.rep ⋯).submodule",
"usedConstants": [
"Projectivization.mk",
"Submodule",
"AddCommGroup.toAddCommMonoid",
"Projectivization.rep",
... | change FiniteDimensional K (K ∙ v.rep) | Lean.Elab.Tactic.evalChange | Lean.Parser.Tactic.change |
Mathlib.Combinatorics.Colex | {
"line": 257,
"column": 2
} | {
"line": 261,
"column": 27
} | [
{
"pp": "α : Type u_1\ninst✝¹ : PartialOrder α\ns : Finset α\na b : α\ninst✝ : DecidableEq α\nha : a ∈ s\nhb : b ∈ s\n⊢ toColex (s.erase a) ≤ toColex (s.erase b) ↔ b ≤ a",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"Colex",
"Finset.Colex.toColex_sdiff_le_toColex_sdiff'",
... | obtain rfl | hab := eq_or_ne a b
· simp
classical
rw [← toColex_sdiff_le_toColex_sdiff', erase_sdiff_erase hab hb, erase_sdiff_erase hab.symm ha,
singleton_le_singleton] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.Colex | {
"line": 257,
"column": 2
} | {
"line": 261,
"column": 27
} | [
{
"pp": "α : Type u_1\ninst✝¹ : PartialOrder α\ns : Finset α\na b : α\ninst✝ : DecidableEq α\nha : a ∈ s\nhb : b ∈ s\n⊢ toColex (s.erase a) ≤ toColex (s.erase b) ↔ b ≤ a",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"Colex",
"Finset.Colex.toColex_sdiff_le_toColex_sdiff'",
... | obtain rfl | hab := eq_or_ne a b
· simp
classical
rw [← toColex_sdiff_le_toColex_sdiff', erase_sdiff_erase hab hb, erase_sdiff_erase hab.symm ha,
singleton_le_singleton] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Colex | {
"line": 275,
"column": 4
} | {
"line": 275,
"column": 36
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder α\ninst✝ : LinearOrder β\nf : α → β\n𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)\ns✝ t✝ u : Finset α\na b : α\nr : ℕ\ns t : Colex (Finset α)\n⊢ s ≤ t ∨ t ≤ s",
"usedConstants": [
"Colex",
"Finset",
"eq_or_ne"
]
}
] | obtain rfl | hts := eq_or_ne t s | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Combinatorics.Configuration | {
"line": 130,
"column": 4
} | {
"line": 130,
"column": 25
} | [
{
"pp": "P : Type u_1\nL : Type u_2\ninst✝³ : Membership P L\ninst✝² : Nondegenerate P L\ninst✝¹ : Fintype P\ninst✝ : Fintype L\nh : Fintype.card L ≤ Fintype.card P\nt : L → Finset P := fun l ↦ {p | p ∉ l}.toFinset\ns : Finset L\n⊢ #s ≤ #(s.biUnion t)",
"usedConstants": [
"Classical.propDecidable",
... | by_cases hs₀ : #s = 0 | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Combinatorics.Configuration | {
"line": 229,
"column": 8
} | {
"line": 233,
"column": 47
} | [
{
"pp": "case refine_2\nP : Type u_1\nL : Type u_2\ninst✝³ : Membership P L\ninst✝² : HasLines P L\ninst✝¹ : Fintype P\ninst✝ : Fintype L\nhc₂ : ¬Fintype.card P ≤ Fintype.card L\nf : L → P\nhf₁ : Function.Injective f\nhf₂ : ∀ (l : L), f l ∉ l\np : P\nhp : ¬∃ a, f a = p\n⊢ 0 < lineCount L p",
"usedConstants"... | · rw [lineCount, Nat.card_eq_fintype_card, Fintype.card_pos_iff]
obtain ⟨l, _⟩ := @exists_line P L _ _ p
exact
let this := not_exists.mp hp l
⟨⟨mkLine this, (mkLine_ax this).2⟩⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Combinatorics.Derangements.Finite | {
"line": 94,
"column": 2
} | {
"line": 94,
"column": 25
} | [
{
"pp": "case ind\nn : ℕ\nhyp : ∀ m < n, card ↑(derangements (Fin m)) = numDerangements m\n⊢ card ↑(derangements (Fin n)) = numDerangements n",
"usedConstants": []
}
] | rcases n with _ | _ | n | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Combinatorics.Configuration | {
"line": 293,
"column": 6
} | {
"line": 296,
"column": 70
} | [
{
"pp": "P : Type u_1\nL : Type u_2\ninst✝³ : Membership P L\ninst✝² : HasLines P L\ninst✝¹ : Fintype P\ninst✝ : Fintype L\nh : Fintype.card P = Fintype.card L\nl₁ l₂ : L\nhl : l₁ ≠ l₂\nf : L → P\nleft✝ : Function.Bijective f\nhf2 : ∀ (l : L), pointCount P l = lineCount L (f l)\nthis✝ : Nontrivial L\nthis : Non... | have h₁ : ∀ p : P, 0 < lineCount L p := fun p =>
Exists.elim (exists_ne p) fun q hq =>
(congr_arg _ Nat.card_eq_fintype_card).mpr
(Fintype.card_pos_iff.mpr ⟨⟨mkLine hq, (mkLine_ax hq).2⟩⟩) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Combinatorics.Configuration | {
"line": 289,
"column": 4
} | {
"line": 313,
"column": 91
} | [
{
"pp": "P : Type u_1\nL : Type u_2\ninst✝³ : Membership P L\ninst✝² : HasLines P L\ninst✝¹ : Fintype P\ninst✝ : Fintype L\nh : Fintype.card P = Fintype.card L\nl₁ l₂ : L\nhl : l₁ ≠ l₂\n⊢ ∃ p ∈ l₁, p ∈ l₂",
"usedConstants": [
"Nontrivial",
"Iff.mpr",
"Eq.mpr",
"Fintype.one_lt_card",
... | classical
obtain ⟨f, _, hf2⟩ := HasLines.exists_bijective_of_card_eq h
haveI : Nontrivial L := ⟨⟨l₁, l₂, hl⟩⟩
haveI := Fintype.one_lt_card_iff_nontrivial.mp ((congr_arg _ h).mpr Fintype.one_lt_card)
have h₁ : ∀ p : P, 0 < lineCount L p := fun p =>
Exists.elim (exists_ne p) fun q hq =>
... | Lean.Elab.Tactic.evalClassical | Lean.Parser.Tactic.classical |
Mathlib.Combinatorics.Configuration | {
"line": 289,
"column": 4
} | {
"line": 313,
"column": 91
} | [
{
"pp": "P : Type u_1\nL : Type u_2\ninst✝³ : Membership P L\ninst✝² : HasLines P L\ninst✝¹ : Fintype P\ninst✝ : Fintype L\nh : Fintype.card P = Fintype.card L\nl₁ l₂ : L\nhl : l₁ ≠ l₂\n⊢ ∃ p ∈ l₁, p ∈ l₂",
"usedConstants": [
"Nontrivial",
"Iff.mpr",
"Eq.mpr",
"Fintype.one_lt_card",
... | classical
obtain ⟨f, _, hf2⟩ := HasLines.exists_bijective_of_card_eq h
haveI : Nontrivial L := ⟨⟨l₁, l₂, hl⟩⟩
haveI := Fintype.one_lt_card_iff_nontrivial.mp ((congr_arg _ h).mpr Fintype.one_lt_card)
have h₁ : ∀ p : P, 0 < lineCount L p := fun p =>
Exists.elim (exists_ne p) fun q hq =>
... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.Configuration | {
"line": 289,
"column": 4
} | {
"line": 313,
"column": 91
} | [
{
"pp": "P : Type u_1\nL : Type u_2\ninst✝³ : Membership P L\ninst✝² : HasLines P L\ninst✝¹ : Fintype P\ninst✝ : Fintype L\nh : Fintype.card P = Fintype.card L\nl₁ l₂ : L\nhl : l₁ ≠ l₂\n⊢ ∃ p ∈ l₁, p ∈ l₂",
"usedConstants": [
"Nontrivial",
"Iff.mpr",
"Eq.mpr",
"Fintype.one_lt_card",
... | classical
obtain ⟨f, _, hf2⟩ := HasLines.exists_bijective_of_card_eq h
haveI : Nontrivial L := ⟨⟨l₁, l₂, hl⟩⟩
haveI := Fintype.one_lt_card_iff_nontrivial.mp ((congr_arg _ h).mpr Fintype.one_lt_card)
have h₁ : ∀ p : P, 0 < lineCount L p := fun p =>
Exists.elim (exists_ne p) fun q hq =>
... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Configuration | {
"line": 405,
"column": 43
} | {
"line": 405,
"column": 61
} | [
{
"pp": "case intro\nP : Type u_1\nL : Type u_2\ninst✝³ : Membership P L\ninst✝² : ProjectivePlane P L\ninst✝¹ : Finite P\ninst✝ : Finite L\np q : P\nl : L\nh : q ∈ l\nval✝ : Fintype { l // q ∈ l }\n⊢ Fintype.card { l // q ∈ l } = Fintype.card { l // q ∈ l } - 1 + 1",
"usedConstants": [
"Eq.mpr",
... | Nat.sub_add_cancel | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Combinatorics.Configuration | {
"line": 451,
"column": 4
} | {
"line": 463,
"column": 93
} | [
{
"pp": "case intro\nP : Type u_1\nL : Type u_2\ninst✝³ : Membership P L\ninst✝² : ProjectivePlane P L\ninst✝¹ : Fintype P\ninst✝ : Finite L\nval✝ : Fintype L\np : P\nϕ : { q // q ≠ p } ≃ (l : { l // p ∈ l }) × { q // q ∈ ↑l ∧ q ≠ p } :=\n { toFun := fun q ↦ ⟨⟨mkLine ⋯, ⋯⟩, ⟨↑q, ⋯⟩⟩, invFun := fun lq ↦ ⟨↑lq.sn... | have h1 : Fintype.card { q // q ≠ p } + 1 = Fintype.card P := by
apply (eq_tsub_iff_add_eq_of_le (Nat.succ_le_of_lt (Fintype.card_pos_iff.mpr ⟨p⟩))).mp
convert! (Fintype.card_subtype_compl _).trans (congr_arg _ (Fintype.card_subtype_eq p))
have h2 : ∀ l : { l : L // p ∈ l }, Fintype.card { q // q ∈ l.1 ... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.Configuration | {
"line": 451,
"column": 4
} | {
"line": 463,
"column": 93
} | [
{
"pp": "case intro\nP : Type u_1\nL : Type u_2\ninst✝³ : Membership P L\ninst✝² : ProjectivePlane P L\ninst✝¹ : Fintype P\ninst✝ : Finite L\nval✝ : Fintype L\np : P\nϕ : { q // q ≠ p } ≃ (l : { l // p ∈ l }) × { q // q ∈ ↑l ∧ q ≠ p } :=\n { toFun := fun q ↦ ⟨⟨mkLine ⋯, ⋯⟩, ⟨↑q, ⋯⟩⟩, invFun := fun lq ↦ ⟨↑lq.sn... | have h1 : Fintype.card { q // q ≠ p } + 1 = Fintype.card P := by
apply (eq_tsub_iff_add_eq_of_le (Nat.succ_le_of_lt (Fintype.card_pos_iff.mpr ⟨p⟩))).mp
convert! (Fintype.card_subtype_compl _).trans (congr_arg _ (Fintype.card_subtype_eq p))
have h2 : ∀ l : { l : L // p ∈ l }, Fintype.card { q // q ∈ l.1 ... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Enumerative.Bell | {
"line": 87,
"column": 4
} | {
"line": 95,
"column": 18
} | [
{
"pp": "case hx\nm : Multiset ℕ\n⊢ (∏ m_1 ∈ m.toFinset, m_1 ! ^ count m_1 m) *\n ∏ x ∈ m.toFinset.erase 0, (count x m)! * ∏ j ∈ Finset.range (count x m), (j * x + x - 1).choose (x - 1) =\n ∏ i ∈ m.toFinset, (i * count i m)!",
"usedConstants": [
"Multiset.toFinset",
"one_pow",
"Eq.... | suffices this : _ by
by_cases hm : 0 ∈ m.toFinset
· rw [← Finset.prod_erase_mul _ _ hm]
rw [← Finset.prod_erase_mul _ _ hm]
simp only [factorial_zero, one_pow, mul_one, zero_mul]
exact this
· nth_rewrite 1 [← Finset.erase_eq_of_notMem hm]
nth_rewrite 3 [← Finset.erase_e... | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSuffices__1 | Lean.Parser.Tactic.tacticSuffices_ |
Mathlib.Combinatorics.Enumerative.DyckWord | {
"line": 157,
"column": 26
} | {
"line": 161,
"column": 32
} | [
{
"pp": "p q : DyckWord\nh : p ≠ 0\ni : ℕ\nhi : count U (List.take i ↑p) = count D (List.take i ↑p)\nk : ℕ\n⊢ count D (List.take k (List.drop i ↑p)) ≤ count U (List.take k (List.drop i ↑p))",
"usedConstants": [
"Eq.mpr",
"instDecidableEqDyckStep",
"Nat.instIsOrderedAddMonoid",
"DyckS... | by
rw [show i = min i (i + k) by omega, ← take_take] at hi
rw [take_drop, ← add_le_add_iff_left (((p.toList.take (i + k)).take i).count U),
← count_append, hi, ← count_append, take_append_drop]
exact p.count_D_le_count_U _ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.Additive.VerySmallDoubling | {
"line": 268,
"column": 8
} | {
"line": 268,
"column": 25
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Group G\ninst✝ : DecidableEq G\nA : Finset G\nh : ↑(#(A * A)) < 3 / 2 * ↑(#A)\na : G\nha : a ∈ A\nz b : G\nhb : b ∈ A\nc : G\nhc : c ∈ A\nhz : a * (b⁻¹ * c * a) = z\nl : Finset G := A ∩ (z * a⁻¹) •> (A⁻¹ * A)\nr : Finset G := a •> (A⁻¹ * A) ∩ z •> A⁻¹\nthis : A⁻¹ * A * (A⁻¹ * A) ... | union_subset_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Combinatorics.Enumerative.DyckWord | {
"line": 275,
"column": 2
} | {
"line": 275,
"column": 42
} | [
{
"pp": "case h\np : DyckWord\nh : p ≠ 0\nlp : 0 < (↑p).length\n⊢ ∃ x ∈ range (↑p).length, decide (count U (List.take (x + 1) ↑p) = count D (List.take (x + 1) ↑p)) = true",
"usedConstants": [
"Eq.mpr",
"instDecidableEqDyckStep",
"DyckStep.U",
"congrArg",
"Membership.mem",
... | simp only [mem_range, decide_eq_true_eq] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Combinatorics.Enumerative.DyckWord | {
"line": 440,
"column": 16
} | {
"line": 440,
"column": 21
} | [
{
"pp": "p q : DyckWord\nr' : List DyckStep\nh : r' ++ ↑p = ↑q\nhc : count U (List.take ((↑q).length - (↑p).length) ↑q) = count D (List.take ((↑q).length - (↑p).length) ↑q)\nr : DyckWord := q.take ((↑q).length - (↑p).length) hc\n⊢ r' = ↑(q.take ((↑q).length - (↑p).length) hc)",
"usedConstants": [
"HSu... | take, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Combinatorics.Enumerative.Partition.GenFun | {
"line": 121,
"column": 4
} | {
"line": 122,
"column": 29
} | [
{
"pp": "R : Type u_1\ninst✝² : CommSemiring R\ninst✝¹ : TopologicalSpace R\ninst✝ : T2Space R\nf : ℕ → ℕ → R\nd : ℕ\ns : Finset ℕ\nhs0 : 0 ∉ s\ng : ℕ →₀ ℕ\nhg : g ∈ s.finsuppAntidiag d\nhg' : g ∉ Set.range toFinsuppAntidiag\nthis : ∃ i ∈ s, (coeff (g i)) (1 + ∑' (j : ℕ), f i (j + 1) • X ^ (i * (j + 1))) = 0\n⊢... | obtain ⟨i, hi, hi'⟩ := this
apply prod_eq_zero hi hi' | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.Enumerative.Partition.GenFun | {
"line": 121,
"column": 4
} | {
"line": 122,
"column": 29
} | [
{
"pp": "R : Type u_1\ninst✝² : CommSemiring R\ninst✝¹ : TopologicalSpace R\ninst✝ : T2Space R\nf : ℕ → ℕ → R\nd : ℕ\ns : Finset ℕ\nhs0 : 0 ∉ s\ng : ℕ →₀ ℕ\nhg : g ∈ s.finsuppAntidiag d\nhg' : g ∉ Set.range toFinsuppAntidiag\nthis : ∃ i ∈ s, (coeff (g i)) (1 + ∑' (j : ℕ), f i (j + 1) • X ^ (i * (j + 1))) = 0\n⊢... | obtain ⟨i, hi, hi'⟩ := this
apply prod_eq_zero hi hi' | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Enumerative.Partition.GenFun | {
"line": 135,
"column": 4
} | {
"line": 135,
"column": 25
} | [
{
"pp": "case refine_3\nR : Type u_1\ninst✝² : CommSemiring R\ninst✝¹ : TopologicalSpace R\ninst✝ : T2Space R\nf : ℕ → ℕ → R\nd : ℕ\ns : Finset ℕ\nhs0 : 0 ∉ s\ng : ℕ →₀ ℕ\nhg : g ∈ s.finsuppAntidiag d\nhprod : ∀ i ∈ s, (coeff (g i)) (1 + ∑' (j : ℕ), f i (j + 1) • X ^ (i * (j + 1))) ≠ 0\nhgne0 : ∀ (i : ℕ), g i ≠... | refine Eq.trans ?_ h1 | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Combinatorics.Enumerative.Partition.Glaisher | {
"line": 99,
"column": 2
} | {
"line": 99,
"column": 43
} | [
{
"pp": "R : Type u_1\ninst✝² : TopologicalSpace R\ninst✝¹ : T2Space R\ninst✝ : CommSemiring R\nm : ℕ\n⊢ Multipliable fun i ↦ ∑ j ∈ range m, X ^ ((i + 1) * j)",
"usedConstants": [
"Nat.eq_zero_or_pos"
]
}
] | rcases Nat.eq_zero_or_pos m with rfl | hm | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | {
"line": 214,
"column": 18
} | {
"line": 214,
"column": 38
} | [
{
"pp": "n : ℕ\n⊢ ↑(ruzsaSzemerediNumberNat (6 * (n / 6) + 3)) ≤ ↑(ruzsaSzemerediNumberNat (n + 3))",
"usedConstants": [
"le_refl",
"Real.partialOrder",
"Real",
"instHDiv",
"Nat.instIsOrderedAddMonoid",
"HMul.hMul",
"Real.instZeroLEOneClass",
"covariant_swap_a... | grw [Nat.mul_div_le] | Mathlib.Tactic._aux_Mathlib_Tactic_GRewrite_Elab___macroRules_Mathlib_Tactic_grwSeq_1 | Mathlib.Tactic.grwSeq |
Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | {
"line": 214,
"column": 18
} | {
"line": 214,
"column": 38
} | [
{
"pp": "n : ℕ\n⊢ ↑(ruzsaSzemerediNumberNat (6 * (n / 6) + 3)) ≤ ↑(ruzsaSzemerediNumberNat (n + 3))",
"usedConstants": [
"le_refl",
"Real.partialOrder",
"Real",
"instHDiv",
"Nat.instIsOrderedAddMonoid",
"HMul.hMul",
"Real.instZeroLEOneClass",
"covariant_swap_a... | grw [Nat.mul_div_le] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | {
"line": 214,
"column": 18
} | {
"line": 214,
"column": 38
} | [
{
"pp": "n : ℕ\n⊢ ↑(ruzsaSzemerediNumberNat (6 * (n / 6) + 3)) ≤ ↑(ruzsaSzemerediNumberNat (n + 3))",
"usedConstants": [
"le_refl",
"Real.partialOrder",
"Real",
"instHDiv",
"Nat.instIsOrderedAddMonoid",
"HMul.hMul",
"Real.instZeroLEOneClass",
"covariant_swap_a... | grw [Nat.mul_div_le] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | {
"line": 219,
"column": 6
} | {
"line": 219,
"column": 24
} | [
{
"pp": "case calc_1\nn : ℕ\n⊢ n ≤ 2 * 3 * (n / 6) + 2 * 3",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"congrArg",
"id",
"HDiv.hDiv",
"instMulNat",
"instOfNatNat",
"LE.le",
"instLENat",
"instHAdd",
"HAdd.hAdd",
"Nat",
... | rw [← mul_add_one] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Combinatorics.Graph.Subgraph | {
"line": 283,
"column": 4
} | {
"line": 283,
"column": 59
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nG H : Graph α β\nhV : V(H) = V(G)\nh : H ≤i G\ne : β\nhe : e ∈ E(G)\n⊢ e ∈ E(H)",
"usedConstants": [
"Graph.exists_isLink_of_mem_edgeSet"
]
}
] | obtain ⟨_, _, hxy⟩ := G.exists_isLink_of_mem_edgeSet he | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Combinatorics.Hindman | {
"line": 146,
"column": 2
} | {
"line": 146,
"column": 67
} | [
{
"pp": "M : Type u_1\ninst✝ : Semigroup M\na : Stream' M\nS : Set (Ultrafilter M) := ⋂ n, {U | ∀ᶠ (m : M) in ↑U, m ∈ FP (Stream'.drop n a)}\n⊢ ∃ U, U * U = U ∧ ∀ᶠ (m : M) in ↑U, m ∈ FP a",
"usedConstants": [
"Semigroup.toMul",
"HMul.hMul",
"Membership.mem",
"Exists",
"exists_i... | have h := exists_idempotent_in_compact_subsemigroup ?_ S ?_ ?_ ?_ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Combinatorics.Hindman | {
"line": 200,
"column": 4
} | {
"line": 202,
"column": 44
} | [
{
"pp": "case h.tail'\nM : Type u_1\ninst✝ : Semigroup M\nU : Ultrafilter M\nU_idem : U * U = U\nexists_elem : ∀ {s : Set M}, s ∈ U → (s ∩ {m | ∀ᶠ (m' : M) in ↑U, m * m' ∈ s}).Nonempty\nelem : { s // s ∈ U } → M := fun p ↦ ⋯.some\nsucc : { s // s ∈ U } → { s // s ∈ U } := fun p ↦ ⟨↑p ∩ {m | elem p * m ∈ ↑p}, ⋯⟩... | rintro p rfl
refine Set.inter_subset_left (ih (succ p) ?_)
rw [Stream'.corec_eq, Stream'.tail_cons] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.Hindman | {
"line": 200,
"column": 4
} | {
"line": 202,
"column": 44
} | [
{
"pp": "case h.tail'\nM : Type u_1\ninst✝ : Semigroup M\nU : Ultrafilter M\nU_idem : U * U = U\nexists_elem : ∀ {s : Set M}, s ∈ U → (s ∩ {m | ∀ᶠ (m' : M) in ↑U, m * m' ∈ s}).Nonempty\nelem : { s // s ∈ U } → M := fun p ↦ ⋯.some\nsucc : { s // s ∈ U } → { s // s ∈ U } := fun p ↦ ⟨↑p ∩ {m | elem p * m ∈ ↑p}, ⋯⟩... | rintro p rfl
refine Set.inter_subset_left (ih (succ p) ?_)
rw [Stream'.corec_eq, Stream'.tail_cons] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Matroid.Minor.Delete | {
"line": 243,
"column": 2
} | {
"line": 243,
"column": 14
} | [
{
"pp": "α : Type u_1\nM : Matroid α\nD : Set α\n⊢ (M ＼ D).loops = M.loops \\ D",
"usedConstants": [
"congrArg",
"Matroid.delete_closure_eq",
"SDiff.sdiff",
"True",
"eq_self",
"Set.instEmptyCollection",
"Matroid.closure",
"of_eq_true",
"congrFun'",
... | simp [loops] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Combinatorics.Matroid.Minor.Delete | {
"line": 243,
"column": 2
} | {
"line": 243,
"column": 14
} | [
{
"pp": "α : Type u_1\nM : Matroid α\nD : Set α\n⊢ (M ＼ D).loops = M.loops \\ D",
"usedConstants": [
"congrArg",
"Matroid.delete_closure_eq",
"SDiff.sdiff",
"True",
"eq_self",
"Set.instEmptyCollection",
"Matroid.closure",
"of_eq_true",
"congrFun'",
... | simp [loops] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.Matroid.Minor.Delete | {
"line": 243,
"column": 2
} | {
"line": 243,
"column": 14
} | [
{
"pp": "α : Type u_1\nM : Matroid α\nD : Set α\n⊢ (M ＼ D).loops = M.loops \\ D",
"usedConstants": [
"congrArg",
"Matroid.delete_closure_eq",
"SDiff.sdiff",
"True",
"eq_self",
"Set.instEmptyCollection",
"Matroid.closure",
"of_eq_true",
"congrFun'",
... | simp [loops] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Matroid.Minor.Contract | {
"line": 134,
"column": 40
} | {
"line": 134,
"column": 57
} | [
{
"pp": "α : Type u_1\nM : Matroid α\nI B : Set α\nhI : M.Indep I\n⊢ Disjoint B I → (M✶.IsBasis ((M.E \\ I) \\ B) (M.E \\ I) ∧ B ⊆ M.E ↔ M✶.IsBase (M.E \\ (I ∪ B)) ∧ I ∪ B ⊆ M.E)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Matroid.E",
"Set.union_subset_iff",
"Disjoint",
"... | union_subset_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Combinatorics.Matroid.Minor.Contract | {
"line": 163,
"column": 4
} | {
"line": 163,
"column": 21
} | [
{
"pp": "α : Type u_1\nM : Matroid α\nI J : Set α\nhI : M.Indep I\n⊢ ¬(Disjoint I J ∧ M.Indep (J ∪ I)) ∧ J ⊆ M.E ∧ Disjoint I J ↔ Disjoint I J ∧ ¬M.Indep (J ∪ I) ∧ J ∪ I ⊆ M.E",
"usedConstants": [
"Eq.mpr",
"ChainCompletePartialOrder.instOfCompleteLattice",
"CompleteBooleanAlgebra.toComple... | union_subset_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.