module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 365
values | kind stringclasses 368
values |
|---|---|---|---|---|---|---|
Mathlib.CategoryTheory.ConcreteCategory.Basic | {
"line": 152,
"column": 2
} | {
"line": 153,
"column": 36
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nFC : C → C → Type u_1\nCC : C → Type w\ninst✝¹ : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)\ninst✝ : ConcreteCategory C FC\nX Y Z : C\nf : X ⟶ Y\ng : Y ⟶ Z\n⊢ ⇑(hom (f ≫ g)) = ⇑(hom g) ∘ ⇑(hom f)",
"usedConstants": [
"CategoryTheory.ConcreteCategory.com... | ext
simp [ConcreteCategory.comp_apply] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.ConcreteCategory.Basic | {
"line": 152,
"column": 2
} | {
"line": 153,
"column": 36
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nFC : C → C → Type u_1\nCC : C → Type w\ninst✝¹ : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)\ninst✝ : ConcreteCategory C FC\nX Y Z : C\nf : X ⟶ Y\ng : Y ⟶ Z\n⊢ ⇑(hom (f ≫ g)) = ⇑(hom g) ∘ ⇑(hom f)",
"usedConstants": [
"CategoryTheory.ConcreteCategory.com... | ext
simp [ConcreteCategory.comp_apply] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.IsTensorProduct | {
"line": 663,
"column": 62
} | {
"line": 664,
"column": 34
} | [
{
"pp": "R : Type u_1\nS : Type v₃\ninst✝¹³ : CommSemiring R\ninst✝¹² : CommSemiring S\ninst✝¹¹ : Algebra R S\nR' : Type u_6\nS' : Type u_7\ninst✝¹⁰ : CommSemiring R'\ninst✝⁹ : CommSemiring S'\ninst✝⁸ : Algebra R R'\ninst✝⁷ : Algebra S S'\ninst✝⁶ : Algebra R' S'\ninst✝⁵ : Algebra R S'\ninst✝⁴ : IsScalarTower R ... | by
simp [Algebra.pushoutDesc_apply] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Logic.Lemmas | {
"line": 36,
"column": 2
} | {
"line": 36,
"column": 19
} | [
{
"pp": "α : Sort u_1\np q : Prop\ninst✝¹ : Decidable p\ninst✝ : Decidable q\na : p → α\nb : ¬p → q → α\nc : ¬p → ¬q → α\n⊢ (dite p a fun hp ↦ dite q (b hp) (c hp)) = if hq : q then dite p a fun hp ↦ b hp hq else dite p a fun hp ↦ c hp hq",
"usedConstants": [
"Eq.mpr",
"dite_congr",
"congr... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Logic.Lemmas | {
"line": 36,
"column": 2
} | {
"line": 36,
"column": 19
} | [
{
"pp": "α : Sort u_1\np q : Prop\ninst✝¹ : Decidable p\ninst✝ : Decidable q\na : p → α\nb : ¬p → q → α\nc : ¬p → ¬q → α\n⊢ (dite p a fun hp ↦ dite q (b hp) (c hp)) = if hq : q then dite p a fun hp ↦ b hp hq else dite p a fun hp ↦ c hp hq",
"usedConstants": [
"Eq.mpr",
"dite_congr",
"congr... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Logic.Lemmas | {
"line": 36,
"column": 2
} | {
"line": 36,
"column": 19
} | [
{
"pp": "α : Sort u_1\np q : Prop\ninst✝¹ : Decidable p\ninst✝ : Decidable q\na : p → α\nb : ¬p → q → α\nc : ¬p → ¬q → α\n⊢ (dite p a fun hp ↦ dite q (b hp) (c hp)) = if hq : q then dite p a fun hp ↦ b hp hq else dite p a fun hp ↦ c hp hq",
"usedConstants": [
"Eq.mpr",
"dite_congr",
"congr... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Logic.Lemmas | {
"line": 41,
"column": 2
} | {
"line": 41,
"column": 19
} | [
{
"pp": "α : Sort u_1\np q : Prop\ninst✝¹ : Decidable p\ninst✝ : Decidable q\na : p → q → α\nb : p → ¬q → α\nc : ¬p → α\n⊢ dite p (fun hp ↦ dite q (a hp) (b hp)) c = if hq : q then dite p (fun hp ↦ a hp hq) c else dite p (fun hp ↦ b hp hq) c",
"usedConstants": [
"Eq.mpr",
"dite_congr",
"co... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Logic.Lemmas | {
"line": 41,
"column": 2
} | {
"line": 41,
"column": 19
} | [
{
"pp": "α : Sort u_1\np q : Prop\ninst✝¹ : Decidable p\ninst✝ : Decidable q\na : p → q → α\nb : p → ¬q → α\nc : ¬p → α\n⊢ dite p (fun hp ↦ dite q (a hp) (b hp)) c = if hq : q then dite p (fun hp ↦ a hp hq) c else dite p (fun hp ↦ b hp hq) c",
"usedConstants": [
"Eq.mpr",
"dite_congr",
"co... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Logic.Lemmas | {
"line": 41,
"column": 2
} | {
"line": 41,
"column": 19
} | [
{
"pp": "α : Sort u_1\np q : Prop\ninst✝¹ : Decidable p\ninst✝ : Decidable q\na : p → q → α\nb : p → ¬q → α\nc : ¬p → α\n⊢ dite p (fun hp ↦ dite q (a hp) (b hp)) c = if hq : q then dite p (fun hp ↦ a hp hq) c else dite p (fun hp ↦ b hp hq) c",
"usedConstants": [
"Eq.mpr",
"dite_congr",
"co... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Quiver.Path | {
"line": 211,
"column": 30
} | {
"line": 211,
"column": 51
} | [
{
"pp": "V : Type u\ninst✝ : Quiver V\na b : V\np : Path a b\nx✝ d : V\nq : Path b d\na✝ : d ⟶ x✝\n⊢ (p.comp (q.cons a✝)).toList = (q.cons a✝).toList ++ p.toList",
"usedConstants": [
"congrArg",
"Quiver.Path.toList",
"Quiver.Path",
"List.cons",
"instHAppendOfAppend",
"Lis... | by simp [toList_comp] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Equivalence | {
"line": 506,
"column": 32
} | {
"line": 506,
"column": 76
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\ne : C ≌ D\nW X X' Y Y' Z : D\nf : W ⟶ X\ng : X ⟶ Y\nh : Y ⟶ Z\nf' : W ⟶ X'\ng' : X' ⟶ Y'\nh' : Y' ⟶ Z\n⊢ f ≫ g ≫ h ≫ e.counitInv.app Z = f' ≫ g' ≫ h' ≫ e.counitInv.app Z ↔ f ≫ g ≫ h = f' ≫ g' ≫ h'",
"usedConstants"... | by simp only [← Category.assoc, cancel_mono] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Cones | {
"line": 707,
"column": 14
} | {
"line": 707,
"column": 36
} | [
{
"pp": "case a\nJ : Type u₁\ninst✝⁴ : Category.{v₁, u₁} J\nK : Type u₂\ninst✝³ : Category.{v₂, u₂} K\nC : Type u₃\ninst✝² : Category.{v₃, u₃} C\nD : Type u₄\ninst✝¹ : Category.{v₄, u₄} D\nE : Type u₅\ninst✝ : Category.{v₅, u₅} E\nF : J ⥤ C\nX Y : Cocone F\nf : X ⟶ Y\nj : Jᵒᵖ\n⊢ X.ι.app (unop j) ≫ f.hom = Y.ι.a... | apply CoconeMorphism.w | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.CategoryTheory.Retract | {
"line": 162,
"column": 9
} | {
"line": 162,
"column": 30
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX✝ Y✝ Z✝ W✝ : C\nf✝ : X✝ ⟶ Y✝\ng✝ : Z✝ ⟶ W✝\nh✝ : RetractArrow f✝ g✝\nX Y Z W : Cᵒᵖ\nf : X ⟶ Y\ng : Z ⟶ W\nh : RetractArrow f g\n⊢ (𝟭 C).map h.r.right.unop ≫ (Arrow.mk g.unop).hom = (Arrow.mk f.unop).hom ≫ (𝟭 C).map h.r... | by simp [← unop_comp] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Retract | {
"line": 165,
"column": 9
} | {
"line": 165,
"column": 30
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX✝ Y✝ Z✝ W✝ : C\nf✝ : X✝ ⟶ Y✝\ng✝ : Z✝ ⟶ W✝\nh✝ : RetractArrow f✝ g✝\nX Y Z W : Cᵒᵖ\nf : X ⟶ Y\ng : Z ⟶ W\nh : RetractArrow f g\n⊢ (𝟭 C).map h.i.right.unop ≫ (Arrow.mk f.unop).hom = (Arrow.mk g.unop).hom ≫ (𝟭 C).map h.i... | by simp [← unop_comp] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | {
"line": 419,
"column": 8
} | {
"line": 420,
"column": 45
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{v₁, u₁} C\nJ : Type u\ninst✝¹ : Category.{v, u} J\nX : J\nhX : IsInitial X\nF : J ⥤ C\ninst✝ : ∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)\ni j : J\nf : i ⟶ j\n⊢ F.map f ≫ inv (F.map (hX.to j)) = inv (F.map (hX.to i)) ≫ 𝟙 (F.obj X)",
"usedConstants": [
"CategoryT... | simp only [IsIso.eq_inv_comp, IsIso.comp_inv_eq, Category.comp_id, ← F.map_comp,
hX.hom_ext (hX.to i ≫ f) (hX.to j)] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.HasLimits | {
"line": 151,
"column": 27
} | {
"line": 151,
"column": 43
} | [
{
"pp": "J : Type u₁\ninst✝³ : Category.{v₁, u₁} J\nK : Type u₂\ninst✝² : Category.{v₂, u₂} K\nC : Type u\ninst✝¹ : Category.{v, u} C\nF✝ F : J ⥤ C\ninst✝ : HasLimit F\nj j' : J\nhj : j = j'\n⊢ F.obj j = F.obj j'",
"usedConstants": [
"Eq.ndrec",
"Eq.refl",
"Eq",
"CategoryTheory.Funct... | by subst hj; rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.HasLimits | {
"line": 704,
"column": 13
} | {
"line": 704,
"column": 29
} | [
{
"pp": "J : Type u₁\ninst✝³ : Category.{v₁, u₁} J\nK : Type u₂\ninst✝² : Category.{v₂, u₂} K\nC : Type u\ninst✝¹ : Category.{v, u} C\nF✝ F : J ⥤ C\ninst✝ : HasColimit F\nj j' : J\nhj : j = j'\n⊢ F.obj j' = F.obj j",
"usedConstants": [
"Eq.ndrec",
"Eq.refl",
"Eq",
"CategoryTheory.Fun... | by subst hj; rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.HasLimits | {
"line": 1011,
"column": 82
} | {
"line": 1015,
"column": 41
} | [
{
"pp": "J : Type u₁\ninst✝⁵ : Category.{v₁, u₁} J\nC : Type u\ninst✝⁴ : Category.{v, u} C\nF : J ⥤ C\nD : Type u'\ninst✝³ : Category.{v', u'} D\ninst✝² : HasColimit F\nG : C ⥤ D\ninst✝¹ : HasColimit (F ⋙ G)\nE : Type u''\ninst✝ : Category.{v'', u''} E\nH : D ⥤ E\nh : HasColimit ((F ⋙ G) ⋙ H)\n⊢ post (F ⋙ G) H ... | by
ext j
rw [← assoc, colimit.ι_post, ← H.map_comp, colimit.ι_post]
haveI : HasColimit (F ⋙ G ⋙ H) := h
exact (colimit.ι_post F (G ⋙ H) j).symm | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Products | {
"line": 797,
"column": 44
} | {
"line": 801,
"column": 48
} | [
{
"pp": "β : Type w\nα : Type w₂\nγ : Type w₃\nC : Type u\ninst✝¹ : Category.{v, u} C\nX Y : C\ne : X ≅ Y\nJ : Type u_1\ninst✝ : Unique J\n⊢ IsLimit (mk X fun x ↦ e.hom)",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"Inhabited.default",
"CategoryTheory.Limits.Fan.pr... | by
refine mkFanLimit _ (fun s ↦ s.proj default ≫ e.inv) (fun s j ↦ ?_) fun s m hm ↦ ?_
· obtain rfl : j = default := Subsingleton.elim _ _
simp
· simpa [← cancel_mono e.hom] using hm default | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | {
"line": 230,
"column": 24
} | {
"line": 230,
"column": 57
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nF : WalkingCospan ⥤ C\nj : WalkingCospan\n⊢ F.obj j = (cospan (F.map inl) (F.map inr)).obj j",
"usedConstants": [
"CategoryTheory.Limits.WalkingCospan.Hom.inl",
"CategoryTheory.Limits.WalkingCospan.right",
"Option.casesOn",
"Option.some... | rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | {
"line": 230,
"column": 24
} | {
"line": 230,
"column": 57
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nF : WalkingCospan ⥤ C\nj : WalkingCospan\n⊢ F.obj j = (cospan (F.map inl) (F.map inr)).obj j",
"usedConstants": [
"CategoryTheory.Limits.WalkingCospan.Hom.inl",
"CategoryTheory.Limits.WalkingCospan.right",
"Option.casesOn",
"Option.some... | rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | {
"line": 230,
"column": 24
} | {
"line": 230,
"column": 57
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nF : WalkingCospan ⥤ C\nj : WalkingCospan\n⊢ F.obj j = (cospan (F.map inl) (F.map inr)).obj j",
"usedConstants": [
"CategoryTheory.Limits.WalkingCospan.Hom.inl",
"CategoryTheory.Limits.WalkingCospan.right",
"Option.casesOn",
"Option.some... | rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | {
"line": 237,
"column": 24
} | {
"line": 237,
"column": 57
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nF : WalkingSpan ⥤ C\nj : WalkingSpan\n⊢ F.obj j = (span (F.map fst) (F.map snd)).obj j",
"usedConstants": [
"CategoryTheory.Limits.WalkingSpan",
"Option.casesOn",
"CategoryTheory.Limits.WalkingSpan.left",
"Option.some",
"CategoryT... | rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | {
"line": 237,
"column": 24
} | {
"line": 237,
"column": 57
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nF : WalkingSpan ⥤ C\nj : WalkingSpan\n⊢ F.obj j = (span (F.map fst) (F.map snd)).obj j",
"usedConstants": [
"CategoryTheory.Limits.WalkingSpan",
"Option.casesOn",
"CategoryTheory.Limits.WalkingSpan.left",
"Option.some",
"CategoryT... | rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | {
"line": 237,
"column": 24
} | {
"line": 237,
"column": 57
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nF : WalkingSpan ⥤ C\nj : WalkingSpan\n⊢ F.obj j = (span (F.map fst) (F.map snd)).obj j",
"usedConstants": [
"CategoryTheory.Limits.WalkingSpan",
"Option.casesOn",
"CategoryTheory.Limits.WalkingSpan.left",
"Option.some",
"CategoryT... | rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1457,
"column": 6
} | {
"line": 1459,
"column": 18
} | [
{
"pp": "case left.right\nC : Type u\ninst✝ : Category.{v, u} C\nX Y Z P✝ : C\nsXY : BinaryFan X Y\nsYZ : BinaryFan Y Z\nP : IsLimit sXY\nQ : IsLimit sYZ\ns : BinaryFan sXY.pt Z\nR : IsLimit s\nt : Cone (pair X sYZ.pt)\nm : t.pt ⟶ (BinaryFan.assoc Q s).pt\nw : ∀ (j : Discrete WalkingPair), m ≫ (BinaryFan.assoc ... | · replace w : m ≫ Q.lift (BinaryFan.mk (s.fst ≫ sXY.snd) s.snd) = t.π.app ⟨.right⟩ := by
simpa using w ⟨.right⟩
simp [← w] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 190,
"column": 2
} | {
"line": 196,
"column": 28
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : HasZeroMorphisms C\nX Y : C\nf : X ⟶ Y\ninst✝ : IsSplitMono f\n⊢ IsZero X ↔ f = 0",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.retraction.congr_simp",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",... | rw [iff_id_eq_zero]
constructor
· intro h
rw [← Category.id_comp f, h, zero_comp]
· intro h
rw [← IsSplitMono.id f]
simp only [h, zero_comp] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 190,
"column": 2
} | {
"line": 196,
"column": 28
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : HasZeroMorphisms C\nX Y : C\nf : X ⟶ Y\ninst✝ : IsSplitMono f\n⊢ IsZero X ↔ f = 0",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.retraction.congr_simp",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",... | rw [iff_id_eq_zero]
constructor
· intro h
rw [← Category.id_comp f, h, zero_comp]
· intro h
rw [← IsSplitMono.id f]
simp only [h, zero_comp] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 773,
"column": 46
} | {
"line": 781,
"column": 8
} | [
{
"pp": "T : Type u₁\ninst✝ : Category.{v₁, u₁} T\nY : T\n⊢ map (𝟙 Y) = 𝟭 (Under Y)",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.instCategoryUnder",
"CategoryTheory.Comma.right",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.ext",
... | by
fapply Functor.ext
· intro x
dsimp [Under, Under.map, Comma.mapLeft]
simp only [Category.id_comp]
exact rfl
· intro x y u
dsimp [Under, Under.map, Comma.mapLeft]
simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.ExactFunctor | {
"line": 190,
"column": 9
} | {
"line": 190,
"column": 65
} | [
{
"pp": "C : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\nF : C ⥤ D\ninst✝¹ : PreservesFiniteLimits F\ninst✝ : PreservesFiniteColimits F\n⊢ exactFunctor C D F",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Limits.PreservesFiniteLimits",
"CategoryTheory.... | simp only [exactFunctor_iff]; constructor <;> assumption | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.ExactFunctor | {
"line": 190,
"column": 9
} | {
"line": 190,
"column": 65
} | [
{
"pp": "C : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\nF : C ⥤ D\ninst✝¹ : PreservesFiniteLimits F\ninst✝ : PreservesFiniteColimits F\n⊢ exactFunctor C D F",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Limits.PreservesFiniteLimits",
"CategoryTheory.... | simp only [exactFunctor_iff]; constructor <;> assumption | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Kernels | {
"line": 185,
"column": 14
} | {
"line": 185,
"column": 66
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : HasZeroMorphisms C\nX Y : C\nf : X ⟶ Y\nW : C\ng : Y ⟶ W\nh : X ⟶ W\nc : KernelFork h\ni : IsLimit c\nhf : Fork.ι c ≫ f = 0\nhfg : f ≫ g = h\ns : Fork f 0\n⊢ (fun s ↦ i.lift (KernelFork.ofι s.ι ⋯)) s ≫ Fork.ι (KernelFork.ofι (Fork.ι c) hf) = s.ι",
"us... | by simp only [KernelFork.ι_ofι, Fork.IsLimit.lift_ι] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Kernels | {
"line": 389,
"column": 2
} | {
"line": 389,
"column": 28
} | [
{
"pp": "case h\nC : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : HasZeroMorphisms C\nX Y : C\n⊢ kernelZeroIsoSource.inv ≫ equalizer.ι 0 0 = kernel.lift 0 (𝟙 X) ⋯ ≫ equalizer.ι 0 0",
"usedConstants": [
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Fork.of... | simp [kernelZeroIsoSource] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 582,
"column": 2
} | {
"line": 582,
"column": 28
} | [
{
"pp": "J : Type w\nC : Type u\ninst✝³ : Category.{v, u} C\ninst✝² : HasZeroMorphisms C\nf g : J → C\ninst✝¹ : HasBiproduct f\ninst✝ : HasBiproduct g\np : (j : J) → f j ⟶ g j\nj : J\n⊢ ι f j ≫ map p = p j ≫ ι g j",
"usedConstants": [
"CategoryTheory.Limits.biproduct.map'",
"Eq.mpr",
"Cate... | rw [biproduct.map_eq_map'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 610,
"column": 2
} | {
"line": 620,
"column": 16
} | [
{
"pp": "J✝ : Type w\nC✝ : Type uC\ninst✝⁸ : Category.{uC', uC} C✝\ninst✝⁷ : HasZeroMorphisms C✝\nD : Type uD\ninst✝⁶ : Category.{uD', uD} D\ninst✝⁵ : HasZeroMorphisms D\nF : J✝ → C✝\nJ : Type w\nK : Type u_1\nC : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasZeroMorphisms C\nf g : J → C\ninst✝² : HasBiproduc... | classical
have : biproduct.map p =
(biproduct.isoCoproduct _).hom ≫ Sigma.map p ≫ (biproduct.isoCoproduct _).inv := by
ext
simp only [map_π, isoCoproduct_hom, isoCoproduct_inv, Category.assoc, ι_desc_assoc,
ι_colimMap_assoc, Discrete.functor_obj_eq_as, Discrete.natTrans_app, colimit.ι_desc_assoc,
... | Lean.Elab.Tactic.evalClassical | Lean.Parser.Tactic.classical |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 610,
"column": 2
} | {
"line": 620,
"column": 16
} | [
{
"pp": "J✝ : Type w\nC✝ : Type uC\ninst✝⁸ : Category.{uC', uC} C✝\ninst✝⁷ : HasZeroMorphisms C✝\nD : Type uD\ninst✝⁶ : Category.{uD', uD} D\ninst✝⁵ : HasZeroMorphisms D\nF : J✝ → C✝\nJ : Type w\nK : Type u_1\nC : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasZeroMorphisms C\nf g : J → C\ninst✝² : HasBiproduc... | classical
have : biproduct.map p =
(biproduct.isoCoproduct _).hom ≫ Sigma.map p ≫ (biproduct.isoCoproduct _).inv := by
ext
simp only [map_π, isoCoproduct_hom, isoCoproduct_inv, Category.assoc, ι_desc_assoc,
ι_colimMap_assoc, Discrete.functor_obj_eq_as, Discrete.natTrans_app, colimit.ι_desc_assoc,
... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 610,
"column": 2
} | {
"line": 620,
"column": 16
} | [
{
"pp": "J✝ : Type w\nC✝ : Type uC\ninst✝⁸ : Category.{uC', uC} C✝\ninst✝⁷ : HasZeroMorphisms C✝\nD : Type uD\ninst✝⁶ : Category.{uD', uD} D\ninst✝⁵ : HasZeroMorphisms D\nF : J✝ → C✝\nJ : Type w\nK : Type u_1\nC : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasZeroMorphisms C\nf g : J → C\ninst✝² : HasBiproduc... | classical
have : biproduct.map p =
(biproduct.isoCoproduct _).hom ≫ Sigma.map p ≫ (biproduct.isoCoproduct _).inv := by
ext
simp only [map_π, isoCoproduct_hom, isoCoproduct_inv, Category.assoc, ι_desc_assoc,
ι_colimMap_assoc, Discrete.functor_obj_eq_as, Discrete.natTrans_app, colimit.ι_desc_assoc,
... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 678,
"column": 2
} | {
"line": 681,
"column": 36
} | [
{
"pp": "case pos\nJ : Type w\nK : Type u_1\nC : Type u\ninst✝³ : Category.{v, u} C\ninst✝² : HasZeroMorphisms C\nf : J → C\ng : K → C\ne : J ≃ K\nw : (j : J) → g (e j) ≅ f j\ninst✝¹ : HasBiproduct f\ninst✝ : HasBiproduct g\nj : J\nk : K\nh : k = e j\n⊢ ι g k ≫ (desc fun k ↦ eqToHom ⋯ ≫ (w (e.symm k)).hom ≫ ι f... | · subst h
simp only [ι_desc_assoc, ← eqToHom_iso_hom_naturality_assoc w (e.symm_apply_apply j).symm,
Equiv.symm_apply_apply, eqToHom_comp_ι, Category.assoc, bicone_ι_π_self, Category.comp_id,
lift_π, bicone_ι_π_self_assoc] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 1052,
"column": 8
} | {
"line": 1052,
"column": 52
} | [
{
"pp": "J✝¹ : Type w\nC✝¹ : Type uC\ninst✝¹⁰ : Category.{uC', uC} C✝¹\ninst✝⁹ : HasZeroMorphisms C✝¹\nD✝ : Type uD\ninst✝⁸ : Category.{uD', uD} D✝\ninst✝⁷ : HasZeroMorphisms D✝\nF : J✝¹ → C✝¹\nJ✝ : Type w\nK : Type u_1\nC✝ : Type u\ninst✝⁶ : Category.{v, u} C✝\ninst✝⁵ : HasZeroMorphisms C✝\nJ : Type w\nC : Typ... | ← biproduct.conePointUniqueUpToIso_hom f hb, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 1055,
"column": 8
} | {
"line": 1055,
"column": 52
} | [
{
"pp": "J✝¹ : Type w\nC✝¹ : Type uC\ninst✝¹⁰ : Category.{uC', uC} C✝¹\ninst✝⁹ : HasZeroMorphisms C✝¹\nD✝ : Type uD\ninst✝⁸ : Category.{uD', uD} D✝\ninst✝⁷ : HasZeroMorphisms D✝\nF : J✝¹ → C✝¹\nJ✝ : Type w\nK : Type u_1\nC✝ : Type u\ninst✝⁶ : Category.{v, u} C✝\ninst✝⁵ : HasZeroMorphisms C✝\nJ : Type w\nC : Typ... | ← biproduct.conePointUniqueUpToIso_hom f hb, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 572,
"column": 6
} | {
"line": 578,
"column": 18
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsColimit b.inrCokernelCofork\nT : C\nf : X ⟶ T\ng : Y ⟶ T\nm : b.toCocone.pt ⟶ T\nh₁ : BinaryCofan.inl b.toCocone ≫ m = f\nh₂ : BinaryCofan.inr b.toCocone ≫ ... | dsimp at m
have h₁' : b.inl ≫ (m - (b.fst ≫ f + b.snd ≫ g)) = 0 := by simpa using sub_eq_zero.2 h₁
have h₂' : b.inr ≫ (m - (b.fst ≫ f + b.snd ≫ g)) = 0 := by simpa using sub_eq_zero.2 h₂
obtain ⟨q : X ⟶ T, hq : b.fst ≫ q = m - (b.fst ≫ f + b.snd ≫ g)⟩ :=
CokernelCofork.IsColimit.desc' hb _ h₂'... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 572,
"column": 6
} | {
"line": 578,
"column": 18
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsColimit b.inrCokernelCofork\nT : C\nf : X ⟶ T\ng : Y ⟶ T\nm : b.toCocone.pt ⟶ T\nh₁ : BinaryCofan.inl b.toCocone ≫ m = f\nh₂ : BinaryCofan.inr b.toCocone ≫ ... | dsimp at m
have h₁' : b.inl ≫ (m - (b.fst ≫ f + b.snd ≫ g)) = 0 := by simpa using sub_eq_zero.2 h₁
have h₂' : b.inr ≫ (m - (b.fst ≫ f + b.snd ≫ g)) = 0 := by simpa using sub_eq_zero.2 h₂
obtain ⟨q : X ⟶ T, hq : b.fst ≫ q = m - (b.fst ≫ f + b.snd ≫ g)⟩ :=
CokernelCofork.IsColimit.desc' hb _ h₂'... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Antidiag.Pi | {
"line": 117,
"column": 4
} | {
"line": 119,
"column": 40
} | [
{
"pp": "case refine_1\nι : Type u_1\nμ : Type u_2\nμ' : Type u_3\ninst✝³ : DecidableEq ι\ninst✝² : AddCommMonoid μ\ninst✝¹ : HasAntidiagonal μ\ninst✝ : DecidableEq μ\nn✝ : μ\ns : Finset ι\nn : μ\ne : ↥s ≃ Fin #s\n⊢ Injective fun f i ↦ if hi : i ∈ s then f (e ⟨i, hi⟩) else 0",
"usedConstants": [
"dite... | rintro f g hfg
ext i
simpa using congr_fun hfg (e.symm i) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Antidiag.Pi | {
"line": 117,
"column": 4
} | {
"line": 119,
"column": 40
} | [
{
"pp": "case refine_1\nι : Type u_1\nμ : Type u_2\nμ' : Type u_3\ninst✝³ : DecidableEq ι\ninst✝² : AddCommMonoid μ\ninst✝¹ : HasAntidiagonal μ\ninst✝ : DecidableEq μ\nn✝ : μ\ns : Finset ι\nn : μ\ne : ↥s ≃ Fin #s\n⊢ Injective fun f i ↦ if hi : i ∈ s then f (e ⟨i, hi⟩) else 0",
"usedConstants": [
"dite... | rintro f g hfg
ext i
simpa using congr_fun hfg (e.symm i) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fintype.Inv | {
"line": 62,
"column": 95
} | {
"line": 65,
"column": 80
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝² : Fintype α\ninst✝¹ : DecidableEq β\nf : α → β\nhf : Injective f\ninst✝ : Nonempty α\n⊢ (Set.range f).restrict (invFun f) = hf.invOfMemRange",
"usedConstants": [
"Function.invFun",
"Set.mem_range",
"Function.Injective.invOfMemRange",
"congr... | by
ext ⟨b, h⟩
apply hf
simp [hf.left_inv_of_invOfMemRange, @invFun_eq _ _ _ f b (Set.mem_range.mp h)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.Enumerative.Composition | {
"line": 843,
"column": 50
} | {
"line": 843,
"column": 63
} | [
{
"pp": "case h\nn✝ n : ℕ\ns : Finset (Fin (n - 1))\ni : Fin (n - 1)\nthis : ↑i + 1 ≠ n\n⊢ i ∈ {i | ⟨↑i + 1, ⋯⟩ ∈ {i | ↑i = 0 ∨ ↑i = ↑(Fin.last n) ∨ ∃ j, ∃ (_ : j ∈ s), ↑i = ↑j + 1}.toFinset}.toFinset ↔ i ∈ s",
"usedConstants": [
"compositionAsSetEquiv._proof_2",
"Finset",
"instDecidableEq... | Fin.val_last, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.GroupTheory.Perm.Support | {
"line": 305,
"column": 2
} | {
"line": 310,
"column": 9
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nl : List (Perm α)\nx : α\nhx : ∀ f ∈ l, f x = x\n⊢ l.prod x = x",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"HMul.hMul",
"Equiv.Perm.instOne",
"congrArg",
"true_or",
"Membership.mem",
... | induction l with
| nil => rfl
| cons f l ih =>
rw [List.prod_cons, mul_apply, ih, hx]
· simp only [List.mem_cons, true_or]
grind | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.GroupTheory.Perm.Support | {
"line": 327,
"column": 4
} | {
"line": 327,
"column": 30
} | [
{
"pp": "case neg\nα : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nc : Perm α\ns : Finset α\nhcs : c.support ≤ s\nx : α\nhx' : x ∉ c.support\n⊢ c x ∈ s ↔ x ∈ s",
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.support",
"Equiv.Perm.notMem_support",
"Equiv.instEquivLike",
"con... | rw [notMem_support.mp hx'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Perm.Support | {
"line": 327,
"column": 4
} | {
"line": 327,
"column": 30
} | [
{
"pp": "case neg\nα : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nc : Perm α\ns : Finset α\nhcs : c.support ≤ s\nx : α\nhx' : x ∉ c.support\n⊢ c x ∈ s ↔ x ∈ s",
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.support",
"Equiv.Perm.notMem_support",
"Equiv.instEquivLike",
"con... | rw [notMem_support.mp hx'] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Support | {
"line": 327,
"column": 4
} | {
"line": 327,
"column": 30
} | [
{
"pp": "case neg\nα : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nc : Perm α\ns : Finset α\nhcs : c.support ≤ s\nx : α\nhx' : x ∉ c.support\n⊢ c x ∈ s ↔ x ∈ s",
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.support",
"Equiv.Perm.notMem_support",
"Equiv.instEquivLike",
"con... | rw [notMem_support.mp hx'] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Support | {
"line": 363,
"column": 69
} | {
"line": 364,
"column": 26
} | [
{
"pp": "α : Type u_1\ninst✝² : DecidableEq α\ninst✝¹ : Fintype α\np : α → Prop\ninst✝ : DecidablePred p\nx : α\nu : Perm (Subtype p)\n⊢ x ∈ (ofSubtype u).support ↔ ∃ (hx : p x), ⟨x, hx⟩ ∈ u.support",
"usedConstants": [
"Iff.mpr",
"Equiv.Perm.support",
"MonoidHom.instFunLike",
"Equiv... | by
simp [support_ofSubtype] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.List | {
"line": 185,
"column": 4
} | {
"line": 192,
"column": 56
} | [
{
"pp": "case cons\nα : Type u_1\ninst✝ : DecidableEq α\ni : ℕ\nx : α\nxs : List α\nw : (x :: xs).Nodup\nh : i < (x :: xs).length\n⊢ (x :: xs).formPerm (x :: xs)[i] = (x :: xs)[(i + 1) % (x :: xs).length]",
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"List.formPerm_... | have : i ≤ xs.length := by
refine Nat.le_of_lt_succ ?_
simpa using h
rcases this.eq_or_lt with (rfl | hn')
· simp
· rw [formPerm_apply_lt_getElem (x :: xs) w _ (Nat.succ_lt_succ hn')]
congr
rw [Nat.mod_eq_of_lt]; simpa [Nat.succ_eq_add_one] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.List | {
"line": 185,
"column": 4
} | {
"line": 192,
"column": 56
} | [
{
"pp": "case cons\nα : Type u_1\ninst✝ : DecidableEq α\ni : ℕ\nx : α\nxs : List α\nw : (x :: xs).Nodup\nh : i < (x :: xs).length\n⊢ (x :: xs).formPerm (x :: xs)[i] = (x :: xs)[(i + 1) % (x :: xs).length]",
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"List.formPerm_... | have : i ≤ xs.length := by
refine Nat.le_of_lt_succ ?_
simpa using h
rcases this.eq_or_lt with (rfl | hn')
· simp
· rw [formPerm_apply_lt_getElem (x :: xs) w _ (Nat.succ_lt_succ hn')]
congr
rw [Nat.mod_eq_of_lt]; simpa [Nat.succ_eq_add_one] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Support | {
"line": 513,
"column": 4
} | {
"line": 513,
"column": 33
} | [
{
"pp": "case cons\nα : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nf hd : Perm α\ntl : List (Perm α)\nIH : f ∈ tl → List.Pairwise Disjoint tl → ∀ x ∈ f.support, f x = tl.prod x\nh : f ∈ hd :: tl\nhl : List.Pairwise Disjoint (hd :: tl)\nx : α\nhx : x ∈ f.support\n⊢ f x = (hd :: tl).prod x",
"usedCo... | rw [List.pairwise_cons] at hl | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Fintype.Perm | {
"line": 50,
"column": 2
} | {
"line": 50,
"column": 33
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nl : List α\nf : Equiv.Perm α\nh : ∀ (x : α), f x ≠ x → x ∈ l\n⊢ f ∈ permsOfList l",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"List.mem_of_ne_of_mem",
"MulOne.toOne",
"False",
"Semigroup.toMul",
"Equiv.instEquivLike",
... | induction l generalizing f with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.GroupTheory.Perm.List | {
"line": 332,
"column": 4
} | {
"line": 332,
"column": 63
} | [
{
"pp": "case cons\nα : Type u_1\ninst✝ : DecidableEq α\nhd : α\ntl : List α\nhl : (hd :: tl).Nodup\n⊢ (hd :: tl).formPerm = 1 ↔ (hd :: tl).length ≤ 1",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"Equiv.Perm.instOne",
"congrArg",
"id",
"instOfNatNat",
"LE.l... | rw [← formPerm_apply_mem_eq_self_iff _ hl hd mem_cons_self] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Perm.Sign | {
"line": 106,
"column": 2
} | {
"line": 106,
"column": 33
} | [
{
"pp": "case intro\nα : Type u\ninst✝¹ : DecidableEq α\ninst✝ : Finite α\nmotive : Perm α → Prop\nf : Perm α\none : motive 1\nswap_mul : ∀ (f : Perm α) (x y : α), x ≠ y → motive f → motive (swap x y * f)\nval✝ : Fintype α\nl : List (Perm α)\nhl : l.prod = f ∧ ∀ g ∈ l, g.IsSwap\n⊢ motive f",
"usedConstants"... | induction l generalizing f with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.GroupTheory.Perm.Closure | {
"line": 106,
"column": 59
} | {
"line": 106,
"column": 70
} | [
{
"pp": "α : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nn : ℕ\nσ : Perm α\nh0 : n.Coprime (orderOf σ)\nh1 : σ.IsCycle\nh2 : σ.support = univ\nx : α\nm : ℕ\nhm : (σ ^ n) ^ m = σ\nh2' : (σ ^ n).support = univ\nh1' : (σ ^ n).IsCycle\n⊢ closure {σ ^ n, swap x ((σ ^ n) x)} ≤ closure {σ, swap x ((σ ^ n) x)}... | closure_le, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Sign | {
"line": 236,
"column": 2
} | {
"line": 236,
"column": 28
} | [
{
"pp": "n : ℕ\nf g : Perm (Fin n)\na b : Fin n\nhab : ⟨a, b⟩ ∈ finPairsLT n\n⊢ (if f (g a) ≤ f (g b) then -1 else 1) =\n (if\n f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤\n f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then\n -1\n else 1) *\n if... | rw [mem_finPairsLT] at hab | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Perm.Sign | {
"line": 313,
"column": 8
} | {
"line": 313,
"column": 25
} | [
{
"pp": "case H.h\nα : Type u\ninst✝ : DecidableEq α\nn : ℕ\nx : α\nl : List α\nf : Perm α\ne : α ≃ Fin n\nh : ∀ (x_1 : α), f x_1 ≠ x_1 → x_1 ∈ x :: l\nhfx : ¬x = f x\nhy : ∀ (y : α), (swap x (f x) * f) y ≠ y → y ∈ l\nx✝ : Fin n\n⊢ ↑(e (if f (e.symm x✝) = x then f x else if e.symm x✝ = x then x else f (e.symm x... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.GroupTheory.Perm.Sign | {
"line": 394,
"column": 20
} | {
"line": 394,
"column": 42
} | [
{
"pp": "α : Type u\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nx y : α\nH : x = y\n⊢ sign (swap x y) = if x = y then 1 else -1",
"usedConstants": [
"MonoidHom.instFunLike",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"MonoidHom",
"Monoid.to... | by simp [H, swap_self] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.Finite | {
"line": 243,
"column": 2
} | {
"line": 243,
"column": 51
} | [
{
"pp": "α : Type u\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nσ : Perm α\nn : ℕ\nh : n.Coprime (orderOf σ)\n⊢ (σ ^ n).support = σ.support",
"usedConstants": [
"DivInvMonoid.toMonoid",
"exists_pow_eq_self_of_coprime",
"Group.toDivInvMonoid",
"Equiv.Perm.permGroup",
"Equiv.Perm... | obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime h | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.GroupTheory.Perm.Sign | {
"line": 568,
"column": 6
} | {
"line": 569,
"column": 66
} | [
{
"pp": "case right.swap_mul\nα : Type u\ninst✝³ : DecidableEq α\nβ : Type v\ninst✝² : Fintype α\ninst✝¹ : DecidableEq β\ninst✝ : Fintype β\nσa : Perm α\nσb' : Perm β\nb₁ b₂ : β\nhb : b₁ ≠ b₂\nih : sign (sumCongr 1 σb') = sign σb'\n⊢ sign (sumCongr 1 (swap b₁ b₂ * σb')) = sign (swap b₁ b₂ * σb')",
"usedCons... | rw [← one_mul (1 : Perm α), ← sumCongr_mul, sign_mul, sign_mul, ih, sumCongr_one_swap,
sign_swap hb, sign_swap (Sum.inr_injective.ne_iff.mpr hb)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Perm.Sign | {
"line": 568,
"column": 6
} | {
"line": 569,
"column": 66
} | [
{
"pp": "case right.swap_mul\nα : Type u\ninst✝³ : DecidableEq α\nβ : Type v\ninst✝² : Fintype α\ninst✝¹ : DecidableEq β\ninst✝ : Fintype β\nσa : Perm α\nσb' : Perm β\nb₁ b₂ : β\nhb : b₁ ≠ b₂\nih : sign (sumCongr 1 σb') = sign σb'\n⊢ sign (sumCongr 1 (swap b₁ b₂ * σb')) = sign (swap b₁ b₂ * σb')",
"usedCons... | rw [← one_mul (1 : Perm α), ← sumCongr_mul, sign_mul, sign_mul, ih, sumCongr_one_swap,
sign_swap hb, sign_swap (Sum.inr_injective.ne_iff.mpr hb)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Sign | {
"line": 568,
"column": 6
} | {
"line": 569,
"column": 66
} | [
{
"pp": "case right.swap_mul\nα : Type u\ninst✝³ : DecidableEq α\nβ : Type v\ninst✝² : Fintype α\ninst✝¹ : DecidableEq β\ninst✝ : Fintype β\nσa : Perm α\nσb' : Perm β\nb₁ b₂ : β\nhb : b₁ ≠ b₂\nih : sign (sumCongr 1 σb') = sign σb'\n⊢ sign (sumCongr 1 (swap b₁ b₂ * σb')) = sign (swap b₁ b₂ * σb')",
"usedCons... | rw [← one_mul (1 : Perm α), ← sumCongr_mul, sign_mul, sign_mul, ih, sumCongr_one_swap,
sign_swap hb, sign_swap (Sum.inr_injective.ne_iff.mpr hb)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 551,
"column": 6
} | {
"line": 551,
"column": 55
} | [
{
"pp": "case intro.mpr\nβ : Type u_3\ninst✝ : Finite β\nf : Perm β\nhf : f.IsCycle\nn : ℕ\nval✝ : Fintype β\nh : n.Coprime (orderOf f)\n⊢ (f ^ n).IsCycle",
"usedConstants": [
"DivInvMonoid.toMonoid",
"exists_pow_eq_self_of_coprime",
"Group.toDivInvMonoid",
"Equiv.Perm.permGroup",
... | obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime h | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Tactic.NormNum.GCD | {
"line": 213,
"column": 37
} | {
"line": 218,
"column": 84
} | [
{
"pp": "n : ℤ\nd : ℕ\nhi : Invertible ↑d\nh : n.natAbs.gcd d = 1\n⊢ IsInt (↑n * ⅟↑d).num n",
"usedConstants": [
"Nat.gcd",
"Iff.mpr",
"Int.cast",
"Eq.mpr",
"Int.instDiv",
"Rat.num",
"instHDiv",
"Invertible.ne_zero",
"GroupWithZero.toDivisionMonoid",
... | by
constructor
have : 0 < d := Nat.pos_iff_ne_zero.mpr <| by simpa using hi.ne_zero
simp_rw [Rat.mul_num, Rat.den_intCast, invOf_eq_inv,
Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
Rat.num_intCast, one_mul, mul_one, h, Nat.cast_one, Int.ediv_one, Int.cast_id] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 615,
"column": 6
} | {
"line": 615,
"column": 32
} | [
{
"pp": "β : Type u_3\ninst✝ : Finite β\nf : Perm β\nhf : f.IsCycle\nhf' : Nat.Prime (orderOf f)\nn : ℕ\nhn : 0 < n\nhn' : n < orderOf f\nval✝ : Fintype β\n⊢ n.Coprime (orderOf f)",
"usedConstants": [
"Nat.Coprime.symm",
"DivInvMonoid.toMonoid",
"Group.toDivInvMonoid",
"orderOf",
... | refine Nat.Coprime.symm ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 414,
"column": 67
} | {
"line": 414,
"column": 88
} | [
{
"pp": "ι : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nl✝¹ : List α\nf : Perm α\nh : ∀ {x : α}, f x ≠ x → x ∈ l✝¹\nl✝ : List α\ng : Perm α\nhfg : ∀ {x : α}, g x ≠ x → f.cycleOf x = g.cycleOf x\nx : α\nl : List α\nhg : ∀ {x_1 : α}, g x_1 ≠ x_1 → x_1 ∈ x :: l\nhx : ¬g x = x\... | sameCycle_apply_right | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Fin | {
"line": 161,
"column": 14
} | {
"line": 161,
"column": 28
} | [
{
"pp": "case pos\nn : ℕ\ni j : Fin n\ninst✝ : NeZero n\nh : i ≤ j\niin : i ∈ Set.range ⇑(castLEEmb ⋯)\nthis✝ : (castLEEmb ⋯).toEquivRange (i.castLT ⋯) = ⟨i, iin⟩\nch : i = j\nthis : (castLEEmb ⋯).toEquivRange.symm ⟨i, iin⟩ = last ↑j\n⊢ ↑⟨(castLEEmb ⋯) ((finRotate (↑j + 1)) (last ↑j)), ⋯⟩ = 0",
"usedConstan... | finRotate_last | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Fin | {
"line": 363,
"column": 4
} | {
"line": 364,
"column": 40
} | [
{
"pp": "case pos\nn : ℕ\ni j k : Fin n\nh : j < k\nhij : i ≤ j\n⊢ (i.cycleIcc j) k = k",
"usedConstants": [
"Eq.mpr",
"Nat.instOrderedSub",
"congrArg",
"setOf",
"HSub.hSub",
"Membership.mem",
"Nat.sub_le",
"id",
"instSubNat",
"LE.le",
"instL... | have kin : k ∈ Set.range (natAdd_castLEEmb (Nat.sub_le n i)) := by
simp [range_natAdd_castLEEmb]; lia | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 816,
"column": 4
} | {
"line": 816,
"column": 19
} | [
{
"pp": "case refine_2\nα : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\ng f✝ : Perm α\n⊢ ∀ (σ : Perm α),\n σ.IsCycle → fun {g} ↦\n ∀ {f : Perm α}, f ∈ g.cycleFactorsFinset → (g * f⁻¹).cycleFactorsFinset = g.cycleFactorsFinset \\ {f}",
"usedConstants": [
"Equiv.Perm"
]
}
] | intro σ hσ f hf | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.LinearAlgebra.Multilinear.DFinsupp | {
"line": 282,
"column": 78
} | {
"line": 282,
"column": 88
} | [
{
"pp": "ι : Type uι\nκ : ι → Type uκ\nR : Type uR\nι' : Type u_1\ninst✝⁵ : DecidableEq ι\ninst✝⁴ : Fintype ι\ninst✝³ : CommSemiring R\ninst✝² : (i : ι) → Fintype (κ i)\ninst✝¹ : (i : ι) → DecidableEq (κ i)\ninst✝ : DecidableEq ι'\np : ((i : ι) → κ i) × ι'\nr : R\nx : (i : ι) → Π₀ (x : κ i), R\n| (r • freeDFins... | smul_apply | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.LinearAlgebra.Multilinear.DFinsupp | {
"line": 287,
"column": 63
} | {
"line": 289,
"column": 32
} | [
{
"pp": "ι : Type uι\nκ : ι → Type uκ\nR : Type uR\nι' : Type u_1\ninst✝⁵ : DecidableEq ι\ninst✝⁴ : Fintype ι\ninst✝³ : CommSemiring R\ninst✝² : (i : ι) → Fintype (κ i)\ninst✝¹ : (i : ι) → DecidableEq (κ i)\ninst✝ : DecidableEq ι'\nr : R\nx : (i : ι) → Π₀ (x : κ i), R\np : (i : ι) → κ i\nj : ι'\nthis : ∀ (l : ι... | by
simpa [freeDFinsuppEquiv_def, MultilinearMap.piRingEquiv, DFinsupp.sigmaCurryEquiv,
fromDFinsuppEquiv_apply] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.LinearAlgebra.Matrix.SemiringInverse | {
"line": 52,
"column": 4
} | {
"line": 52,
"column": 18
} | [
{
"pp": "n : Type u_1\nR : Type u_3\ninst✝² : Fintype n\ninst✝¹ : DecidableEq n\ninst✝ : CommSemiring R\nd : n → R\nσ : Perm n\nhσ : σ ∈ ofSign (-1)\n⊢ σ ≠ 1",
"usedConstants": [
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"Equiv.Perm.instOne",
"M... | contrapose! hσ | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.LinearAlgebra.Matrix.SemiringInverse | {
"line": 97,
"column": 4
} | {
"line": 97,
"column": 18
} | [
{
"pp": "n : Type u_1\nR : Type u_3\ninst✝² : Fintype n\ninst✝¹ : DecidableEq n\ninst✝ : CommSemiring R\nA B : Matrix n n R\nhf : ∀ {s t : ℤˣ} {σ : Perm n}, σ ∈ ofSign s → ofSign (t * s) = Finset.map (mulRightEmbedding σ) (ofSign t)\nι : Perm n ↪ n → n := { toFun := fun e ↦ ⇑e, inj' := ⋯ }\nhι : ∀ {σ : Perm n} ... | contrapose! hσ | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.LinearAlgebra.Matrix.SemiringInverse | {
"line": 204,
"column": 11
} | {
"line": 204,
"column": 19
} | [
{
"pp": "n : Type u_1\nR : Type u_3\ninst✝² : Fintype n\ninst✝¹ : DecidableEq n\ninst✝ : CommSemiring R\nA B : Matrix n n R\nhAB : A * B = 1\nkey : A * (B * adjp 1 B + detp (-1) B • 1) = A * (B * adjp (-1) B + detp 1 B • 1)\n⊢ detp 1 B • A + adjp (-1) B = detp (-1) B • A + adjp 1 B",
"usedConstants": [
... | mul_add, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.GroupTheory.Perm.Cycle.Type | {
"line": 381,
"column": 4
} | {
"line": 381,
"column": 35
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\ninst✝ : DecidableEq α\nf : Function.End α\np n : ℕ\nhp : Fact (Nat.Prime p)\nhf : f ^ p ^ n = 1\nσ : α ≃ α := { toFun := f, invFun := f ^ (p ^ n - 1), left_inv := ⋯, right_inv := ⋯ }\n⊢ σ ^ p ^ n = 1",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",... | rw [DFunLike.ext'_iff, coe_pow] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.LinearAlgebra.Multilinear.Basic | {
"line": 498,
"column": 6
} | {
"line": 498,
"column": 81
} | [
{
"pp": "R : Type uR\nι : Type uι\nM₁ : ι → Type v₁\nM₂ : Type v₂\ninst✝⁶ : Semiring R\ninst✝⁵ : (i : ι) → AddCommMonoid (M₁ i)\ninst✝⁴ : AddCommMonoid M₂\ninst✝³ : (i : ι) → Module R (M₁ i)\ninst✝² : Module R M₂\nf : MultilinearMap R M₁ M₂\nα : ι → Type u_1\ng : (i : ι) → α i → M₁ i\ninst✝¹ : DecidableEq ι\nin... | exact le_antisymm this (Nat.succ_le_of_lt (_root_.pos_iff_ne_zero.mpr pos)) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 162,
"column": 28
} | {
"line": 162,
"column": 60
} | [
{
"pp": "n : Type u_2\ninst✝² : DecidableEq n\ninst✝¹ : Fintype n\nR : Type v\ninst✝ : CommRing R\nM N : Matrix n n R\nσ : Perm n\nx✝ : σ ∈ univ\nτ : Perm n\nthis : ∏ j, M (τ j) (σ j) = ∏ j, M ((τ * σ⁻¹) j) j\n⊢ ↑↑(sign (τ * σ⁻¹ * σ)) = ↑↑(sign τ)",
"usedConstants": [
"Int.cast",
"Units.val",
... | simp only [inv_mul_cancel_right] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 162,
"column": 28
} | {
"line": 162,
"column": 60
} | [
{
"pp": "n : Type u_2\ninst✝² : DecidableEq n\ninst✝¹ : Fintype n\nR : Type v\ninst✝ : CommRing R\nM N : Matrix n n R\nσ : Perm n\nx✝ : σ ∈ univ\nτ : Perm n\nthis : ∏ j, M (τ j) (σ j) = ∏ j, M ((τ * σ⁻¹) j) j\n⊢ ↑↑(sign (τ * σ⁻¹ * σ)) = ↑↑(sign τ)",
"usedConstants": [
"Int.cast",
"Units.val",
... | simp only [inv_mul_cancel_right] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 162,
"column": 28
} | {
"line": 162,
"column": 60
} | [
{
"pp": "n : Type u_2\ninst✝² : DecidableEq n\ninst✝¹ : Fintype n\nR : Type v\ninst✝ : CommRing R\nM N : Matrix n n R\nσ : Perm n\nx✝ : σ ∈ univ\nτ : Perm n\nthis : ∏ j, M (τ j) (σ j) = ∏ j, M ((τ * σ⁻¹) j) j\n⊢ ↑↑(sign (τ * σ⁻¹ * σ)) = ↑↑(sign τ)",
"usedConstants": [
"Int.cast",
"Units.val",
... | simp only [inv_mul_cancel_right] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 422,
"column": 53
} | {
"line": 422,
"column": 62
} | [
{
"pp": "case insert\nn : Type u_2\ninst✝² : DecidableEq n\ninst✝¹ : Fintype n\nR : Type v\ninst✝ : CommRing R\nM : Matrix n n R\nj : n\nc : n → R\na : R\nk : n\ns✝ : Finset n\nhk : k ∉ s✝\nh_ind : j ∉ s✝ → (M.updateRow j (a • M j + ∑ k ∈ s✝, c k • M k)).det = a • M.det\nhj : j ∉ insert k s✝\nh : k ≠ j\n⊢ (M.up... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 498,
"column": 2
} | {
"line": 499,
"column": 48
} | [
{
"pp": "m : Type u_1\ninst✝³ : DecidableEq m\ninst✝² : Fintype m\nR : Type v\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\nA : Matrix m m R\nhA : ¬LinearIndependent R fun i ↦ Aᵀ i\n⊢ A.det = 0",
"usedConstants": [
"Pi.Function.module",
"Mathlib.Tactic.Contrapose.contrapose₂",
"NonUnitalCommRi... | contrapose! hA
exact linearIndependent_cols_of_det_ne_zero hA | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 498,
"column": 2
} | {
"line": 499,
"column": 48
} | [
{
"pp": "m : Type u_1\ninst✝³ : DecidableEq m\ninst✝² : Fintype m\nR : Type v\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\nA : Matrix m m R\nhA : ¬LinearIndependent R fun i ↦ Aᵀ i\n⊢ A.det = 0",
"usedConstants": [
"Pi.Function.module",
"Mathlib.Tactic.Contrapose.contrapose₂",
"NonUnitalCommRi... | contrapose! hA
exact linearIndependent_cols_of_det_ne_zero hA | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 514,
"column": 4
} | {
"line": 514,
"column": 13
} | [
{
"pp": "n : Type u_2\ninst✝³ : DecidableEq n\ninst✝² : Fintype n\nR : Type v\ninst✝¹ : CommRing R\ninst✝ : Nontrivial n\nu v : n → R\ni j : n\nhij : i ≠ j\nuv' : Matrix n n R := ((vecMulVec u v).updateRow i v).updateRow j v\nhuv' : uv'.det = 0\nthis : vecMulVec u v = (uv'.updateRow i (u i • uv' i)).updateRow j... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Creates | {
"line": 666,
"column": 4
} | {
"line": 666,
"column": 36
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝³ : Category.{v₂, u₂} D\nJ : Type w\ninst✝² : Category.{w', w} J\nK : J ⥤ C\nE : Type u₃\nℰ : Category.{v₃, u₃} E\nF : C ⥤ D\nG : D ⥤ E\ninst✝¹ : CreatesLimit K F\ninst✝ : CreatesLimit (K ⋙ F) G\nc : Cone (K ⋙ F ⋙ G)\nt : IsLimit c\n⊢ Liftabl... | let c' : Cone ((K ⋙ F) ⋙ G) := c | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.CategoryTheory.Limits.Types.Images | {
"line": 119,
"column": 61
} | {
"line": 119,
"column": 69
} | [
{
"pp": "F : ℕᵒᵖ ⥤ Type u\nc : Cone F\nhc : IsLimit c\nhF : ∀ (n : ℕ), Function.Surjective (F.map (homOfLE ⋯).op)\ni : c.pt ≅ (limitCone F).pt := hc.conePointUniqueUpToIso (limitConeIsLimit F)\n⊢ c.π.app (Opposite.op 0) = i.hom ≫ (limitCone F).π.app (Opposite.op 0)",
"usedConstants": [
"CategoryTheory... | simp [i] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 743,
"column": 59
} | {
"line": 743,
"column": 79
} | [
{
"pp": "case refine_2\nR : Type v\ninst✝ : CommRing R\nn : ℕ\nA : Matrix (Fin n.succ) (Fin n.succ) R\ni✝ : Fin n.succ\nx✝ : i✝ ∈ univ\ni : Fin n\nthis : (-1) ^ ↑i = ↑↑(sign i.cycleRange)\n⊢ ∑ y, sign (decomposeFin.symm (i.succ, y)) • ∏ x, A ((decomposeFin.symm (i.succ, y)) x) x =\n -1 * (↑↑(sign i.cycleRang... | mul_left_comm (ε _), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Filtered.Basic | {
"line": 249,
"column": 4
} | {
"line": 250,
"column": 60
} | [
{
"pp": "case empty\nC : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : IsFiltered C\nO : Finset C\nH : Finset ((X : C) ×' (Y : C) ×' (_ : X ∈ O) ×' (_ : Y ∈ O) ×' (X ⟶ Y))\n⊢ ∃ S T, ∀ {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f : X ⟶ Y}, ⟨X, ⟨Y, ⟨mX, ⟨mY, f⟩⟩⟩⟩ ∈ ∅ → f ≫ T mY = T mX",
"usedConstants": [
"Cat... | obtain ⟨S, f⟩ := sup_objs_exists O
exact ⟨S, fun mX => (f mX).some, by rintro - - - - - ⟨⟩⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Filtered.Basic | {
"line": 249,
"column": 4
} | {
"line": 250,
"column": 60
} | [
{
"pp": "case empty\nC : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : IsFiltered C\nO : Finset C\nH : Finset ((X : C) ×' (Y : C) ×' (_ : X ∈ O) ×' (_ : Y ∈ O) ×' (X ⟶ Y))\n⊢ ∃ S T, ∀ {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f : X ⟶ Y}, ⟨X, ⟨Y, ⟨mX, ⟨mY, f⟩⟩⟩⟩ ∈ ∅ → f ≫ T mY = T mX",
"usedConstants": [
"Cat... | obtain ⟨S, f⟩ := sup_objs_exists O
exact ⟨S, fun mX => (f mX).some, by rintro - - - - - ⟨⟩⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Yoneda | {
"line": 156,
"column": 4
} | {
"line": 156,
"column": 90
} | [
{
"pp": "case a.a.h\nC : Type u\ninst✝¹ : Category.{v, u} C\nJ : Type w\ninst✝ : Category.{t, w} J\nF : J ⥤ C\nc : Cone F\nhc : (X : Cᵒᵖ) → IsLimit ((coyoneda.obj X).mapCone c)\ns : Cone F\nm : s.pt ⟶ c.pt\nhm : ∀ (j : J), m ≫ c.π.app j = s.π.app j\nj : J\n⊢ m ≫ c.π.app j = (hc (op s.pt)).lift ((coyoneda.obj (o... | have eq := congr_fun ((hc (op s.pt)).fac ((coyoneda.obj (op s.pt)).mapCone s) j) (𝟙 _) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 496,
"column": 2
} | {
"line": 496,
"column": 19
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nP : Prop\ninst✝ : Decidable P\nX Y Z : C\nf : P → (Y ⟶ Z)\nf' : ¬P → (Y ⟶ Z)\n⊢ (X ◁ if h : P then f h else f' h) = if h : P then X ◁ f h else X ◁ f' h",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.MonoidalCategoryStr... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 496,
"column": 2
} | {
"line": 496,
"column": 19
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nP : Prop\ninst✝ : Decidable P\nX Y Z : C\nf : P → (Y ⟶ Z)\nf' : ¬P → (Y ⟶ Z)\n⊢ (X ◁ if h : P then f h else f' h) = if h : P then X ◁ f h else X ◁ f' h",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.MonoidalCategoryStr... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 496,
"column": 2
} | {
"line": 496,
"column": 19
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nP : Prop\ninst✝ : Decidable P\nX Y Z : C\nf : P → (Y ⟶ Z)\nf' : ¬P → (Y ⟶ Z)\n⊢ (X ◁ if h : P then f h else f' h) = if h : P then X ◁ f h else X ◁ f' h",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.MonoidalCategoryStr... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 501,
"column": 2
} | {
"line": 501,
"column": 19
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nP : Prop\ninst✝ : Decidable P\nX Y : C\nf : P → (X ⟶ Y)\nf' : ¬P → (X ⟶ Y)\nZ : C\n⊢ (if h : P then f h else f' h) ▷ Z = if h : P then f h ▷ Z else f' h ▷ Z",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 501,
"column": 2
} | {
"line": 501,
"column": 19
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nP : Prop\ninst✝ : Decidable P\nX Y : C\nf : P → (X ⟶ Y)\nf' : ¬P → (X ⟶ Y)\nZ : C\n⊢ (if h : P then f h else f' h) ▷ Z = if h : P then f h ▷ Z else f' h ▷ Z",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 501,
"column": 2
} | {
"line": 501,
"column": 19
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nP : Prop\ninst✝ : Decidable P\nX Y : C\nf : P → (X ⟶ Y)\nf' : ¬P → (X ⟶ Y)\nZ : C\n⊢ (if h : P then f h else f' h) ▷ Z = if h : P then f h ▷ Z else f' h ▷ Z",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 505,
"column": 48
} | {
"line": 505,
"column": 65
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nP : Prop\ninst✝ : Decidable P\nW X Y Z : C\nf : W ⟶ X\ng : P → (Y ⟶ Z)\ng' : ¬P → (Y ⟶ Z)\n⊢ (f ⊗ₘ if h : P then g h else g' h) = if h : P then f ⊗ₘ g h else f ⊗ₘ g' h",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Cat... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 505,
"column": 48
} | {
"line": 505,
"column": 65
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nP : Prop\ninst✝ : Decidable P\nW X Y Z : C\nf : W ⟶ X\ng : P → (Y ⟶ Z)\ng' : ¬P → (Y ⟶ Z)\n⊢ (f ⊗ₘ if h : P then g h else g' h) = if h : P then f ⊗ₘ g h else f ⊗ₘ g' h",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Cat... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.