module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.Data.Sym.Sym2 | {
"line": 981,
"column": 89
} | {
"line": 981,
"column": 94
} | {
"line": 983,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Finset α\n⊢ {x ∈ image (uncurry Sym2.mk) (s ×ˢ s) | x.IsDiag} = image (uncurry Sym2.mk) s.diag",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Finset.mem_filter._simp_1",
"Sym2.Rel",
"Sym2.eq._simp_1",
... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Data.Sym.Sym2 | {
"line": 981,
"column": 89
} | {
"line": 981,
"column": 94
} | {
"line": 983,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Finset α\n⊢ {x ∈ image (uncurry Sym2.mk) (s ×ˢ s) | x.IsDiag} = image (uncurry Sym2.mk) s.diag",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Finset.mem_filter._simp_1",
"Sym2.Rel",
"Sym2.eq._simp_1",
... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Sym.Sym2 | {
"line": 981,
"column": 89
} | {
"line": 981,
"column": 94
} | {
"line": 983,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Finset α\n⊢ {x ∈ image (uncurry Sym2.mk) (s ×ˢ s) | x.IsDiag} = image (uncurry Sym2.mk) s.diag",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Finset.mem_filter._simp_1",
"Sym2.Rel",
"Sym2.eq._simp_1",
... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sym.Sym2 | {
"line": 984,
"column": 93
} | {
"line": 984,
"column": 98
} | {
"line": 986,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Finset α\n⊢ {x ∈ image (uncurry Sym2.mk) (s ×ˢ s) | ¬x.IsDiag} = image (uncurry Sym2.mk) s.offDiag",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"instDecidableNot",
"False",
"Finset.mem_filter._simp_1",
... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Data.Sym.Sym2 | {
"line": 984,
"column": 93
} | {
"line": 984,
"column": 98
} | {
"line": 986,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Finset α\n⊢ {x ∈ image (uncurry Sym2.mk) (s ×ˢ s) | ¬x.IsDiag} = image (uncurry Sym2.mk) s.offDiag",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"instDecidableNot",
"False",
"Finset.mem_filter._simp_1",
... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Sym.Sym2 | {
"line": 984,
"column": 93
} | {
"line": 984,
"column": 98
} | {
"line": 986,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Finset α\n⊢ {x ∈ image (uncurry Sym2.mk) (s ×ˢ s) | ¬x.IsDiag} = image (uncurry Sym2.mk) s.offDiag",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"instDecidableNot",
"False",
"Finset.mem_filter._simp_1",
... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sym.Sym2 | {
"line": 1041,
"column": 80
} | {
"line": 1041,
"column": 85
} | {
"line": 1043,
"column": 0
} | [
{
"pp": "case mk\nα : Type u_1\ns : Set α\nx✝ : Sym2 α\nx y : α\n⊢ Quot.mk (Rel α) (x, y) ∈ s.sym2 ↔ Quot.mk (Rel α) (x, y) ∈ uncurry Sym2.mk '' s ×ˢ s",
"ppTerm": "?mk",
"assigned": true,
"usedConstants": [
"Set.instSProd",
"Eq.mpr",
"Sym2.Rel",
"Sym2.eq._simp_1",
"Sym... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Data.Sym.Sym2 | {
"line": 1051,
"column": 14
} | {
"line": 1051,
"column": 19
} | {
"line": 1053,
"column": 0
} | [
{
"pp": "case mk\nα : Type u_1\na : α\ns : Set α\nx✝ : Sym2 α\nx y : α\n⊢ Quot.mk (Rel α) (x, y) ∈ (insert a s).sym2 ↔ Quot.mk (Rel α) (x, y) ∈ (fun b ↦ s(a, b)) '' insert a s ∪ s.sym2",
"ppTerm": "?mk",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Sym2.Rel",
"Sym2.eq._simp_1",
... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Functor.FullyFaithful | {
"line": 193,
"column": 35
} | {
"line": 197,
"column": 17
} | {
"line": 199,
"column": 0
} | [
{
"pp": "case mk\nC : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nE : Type u_1\ninst✝ : Category.{v_1, u_1} E\nX✝ Y✝ : C\nF : C ⥤ D\nX Y Z : C\nhF h₂ : F.FullyFaithful\nthis : F.Faithful\nf₁ : {X Y : C} → (F.obj X ⟶ F.obj Y) → (X ⟶ Y)\nhf₁ : ∀ {X Y : C} (f : F.obj X ⟶ F.obj... | [] | cases h₂ with | mk f₂ hf₂ _ =>
simp only [Functor.FullyFaithful.mk.injEq]
ext
apply F.map_injective
rw [hf₁, hf₂] | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.CategoryTheory.Functor.FullyFaithful | {
"line": 193,
"column": 35
} | {
"line": 197,
"column": 17
} | {
"line": 199,
"column": 0
} | [
{
"pp": "case mk\nC : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nE : Type u_1\ninst✝ : Category.{v_1, u_1} E\nX✝ Y✝ : C\nF : C ⥤ D\nX Y Z : C\nhF h₂ : F.FullyFaithful\nthis : F.Faithful\nf₁ : {X Y : C} → (F.obj X ⟶ F.obj Y) → (X ⟶ Y)\nhf₁ : ∀ {X Y : C} (f : F.obj X ⟶ F.obj... | [] | cases h₂ with | mk f₂ hf₂ _ =>
simp only [Functor.FullyFaithful.mk.injEq]
ext
apply F.map_injective
rw [hf₁, hf₂] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Functor.FullyFaithful | {
"line": 193,
"column": 35
} | {
"line": 197,
"column": 17
} | {
"line": 199,
"column": 0
} | [
{
"pp": "case mk\nC : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nE : Type u_1\ninst✝ : Category.{v_1, u_1} E\nX✝ Y✝ : C\nF : C ⥤ D\nX Y Z : C\nhF h₂ : F.FullyFaithful\nthis : F.Faithful\nf₁ : {X Y : C} → (F.obj X ⟶ F.obj Y) → (X ⟶ Y)\nhf₁ : ∀ {X Y : C} (f : F.obj X ⟶ F.obj... | [] | cases h₂ with | mk f₂ hf₂ _ =>
simp only [Functor.FullyFaithful.mk.injEq]
ext
apply F.map_injective
rw [hf₁, hf₂] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.ObjectProperty.Basic | {
"line": 174,
"column": 2
} | {
"line": 174,
"column": 23
} | {
"line": 175,
"column": 2
} | [
{
"pp": "C : Type u\nD : Type u'\ninst✝¹ : Category.{v, u} C\ninst✝ : Category.{v', u'} D\nP Q : ObjectProperty C\nh : P ≤ Q\nF : C ⥤ D\n⊢ P.map F ≤ Q.map F",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"CategoryTheory.Iso",
"And.casesOn",
"And",
"Exists.casesOn",... | [
"C : Type u\nD : Type u'\ninst✝¹ : Category.{v, u} C\ninst✝ : Category.{v', u'} D\nP Q : ObjectProperty C\nh : P ≤ Q\nF : C ⥤ D\nX : D\nY : C\nhY : P Y\ne : F.obj Y ≅ X\n⊢ Q.map F X"
] | rintro X ⟨Y, hY, ⟨e⟩⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Combinatorics.Quiver.Path | {
"line": 254,
"column": 28
} | {
"line": 254,
"column": 62
} | {
"line": 256,
"column": 0
} | [
{
"pp": "V✝ : Type u\ninst✝² : Quiver V✝\na b c d : V✝\ninst✝¹ : ∀ (a b : V✝), Subsingleton (a ⟶ b)\nV : Type u_1\ninst✝ : Quiver V\nv w : V\np q : Path v w\na✝² x✝³ : V\nx✝² : Path a✝² x✝³\nb✝ : V\na✝¹ : Path a✝² b✝\na✝ : b✝ ⟶ x✝³\nx✝¹ x✝ : BoundedPaths a✝² x✝³ 0\nhp : x✝².length ≤ 0\nhq : (a✝¹.cons a✝).length... | [] | by simp [Quiver.Path.length] at hq | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms | {
"line": 85,
"column": 41
} | {
"line": 85,
"column": 68
} | {
"line": 85,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nP : ObjectProperty C\nh : P.isoClosure = P\n⊢ P.IsClosedUnderIsomorphisms",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"inferInstance",
"id",
"CategoryTheory.ObjectProperty.isoClosure",
... | [] | by rw [← h]; infer_instance | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms | {
"line": 102,
"column": 4
} | {
"line": 102,
"column": 25
} | {
"line": 103,
"column": 4
} | [
{
"pp": "case refine_2\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nP : ObjectProperty C\nF : C ⥤ D\n⊢ P.map F ≤ (P.strictMap F).isoClosure",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"CategoryTheory.ObjectProperty.strictMap",
"Cate... | [
"case refine_2\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nP : ObjectProperty C\nF : C ⥤ D\nX : D\nY : C\nhY : P Y\ne : F.obj Y ≅ X\n⊢ (P.strictMap F).isoClosure X"
] | rintro X ⟨Y, hY, ⟨e⟩⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.CategoryTheory.EqToHom | {
"line": 375,
"column": 74
} | {
"line": 377,
"column": 6
} | {
"line": 379,
"column": 0
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nι : Type u_2\nF G : ι → C\nα : (i : ι) → F i ⟶ G i\ni j : ι\nh : i = j\n⊢ α i = eqToHom ⋯ ≫ α j ≫ eqToHom ⋯",
"ppTerm": "?m.35",
"assigned": true,
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg... | [] | by
subst h
simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Types.Basic | {
"line": 60,
"column": 24
} | {
"line": 60,
"column": 29
} | {
"line": 62,
"column": 0
} | [
{
"pp": "X : Type u_1\nY : Type u_2\nx✝ : Fun X Y\n⊢ ∀ ⦃a₂ : Fun X Y⦄, (fun f x ↦ f.toFun x) x✝ = (fun f x ↦ f.toFun x) a₂ → x✝ = a₂",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"congrArg",
"id",
"TypeCat.Fun.toFun",
"TypeCat.Fun.ext",
"funext",
"Type... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Types.Basic | {
"line": 60,
"column": 24
} | {
"line": 60,
"column": 29
} | {
"line": 62,
"column": 0
} | [
{
"pp": "X : Type u_1\nY : Type u_2\nx✝ : Fun X Y\n⊢ ∀ ⦃a₂ : Fun X Y⦄, (fun f x ↦ f.toFun x) x✝ = (fun f x ↦ f.toFun x) a₂ → x✝ = a₂",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"congrArg",
"id",
"TypeCat.Fun.toFun",
"TypeCat.Fun.ext",
"funext",
"Type... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Types.Basic | {
"line": 60,
"column": 24
} | {
"line": 60,
"column": 29
} | {
"line": 62,
"column": 0
} | [
{
"pp": "X : Type u_1\nY : Type u_2\nx✝ : Fun X Y\n⊢ ∀ ⦃a₂ : Fun X Y⦄, (fun f x ↦ f.toFun x) x✝ = (fun f x ↦ f.toFun x) a₂ → x✝ = a₂",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"congrArg",
"id",
"TypeCat.Fun.toFun",
"TypeCat.Fun.ext",
"funext",
"Type... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.MorphismProperty.Basic | {
"line": 662,
"column": 36
} | {
"line": 664,
"column": 57
} | {
"line": 666,
"column": 0
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\nD : Type u_1\ninst✝² : Category.{v_1, u_1} D\nP : MorphismProperty C\ninst✝¹ : P.RespectsIso\nF : C ⥤ D\ninst✝ : F.IsEquivalence\n⊢ (P.map F).inverseImage F = P",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"CategoryTheory.MorphismPr... | [] | by
erw [((P.map F).inverseImage_equivalence_inverse_eq_map_functor (F.asEquivalence)), map_map,
P.map_eq_of_iso F.asEquivalence.unitIso.symm, map_id] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Category.Ring.Basic | {
"line": 189,
"column": 4
} | {
"line": 189,
"column": 47
} | {
"line": 190,
"column": 4
} | [
{
"pp": "X Y : SemiRingCat\nf : X ⟶ Y\nx✝ : IsIso ((forget SemiRingCat).map f)\n⊢ IsIso f",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"SemiRingCat.instConcreteCategoryRingHomCarrier",
"RingHom",
"SemiRingCat.carrier",
"CategoryTheory.Iso",
"CategoryTheory.... | [
"X Y : SemiRingCat\nf : X ⟶ Y\nx✝ : IsIso ((forget SemiRingCat).map f)\ni : (forget SemiRingCat).obj X ≅ (forget SemiRingCat).obj Y := asIso ((forget SemiRingCat).map f)\n⊢ IsIso f"
] | let i := asIso ((forget SemiRingCat).map f) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 572,
"column": 21
} | {
"line": 572,
"column": 26
} | {
"line": 573,
"column": 6
} | [
{
"pp": "α : Type u\n⊢ Iso.toEquiv 1 = 1",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Monoid.toMulOneClass",
"CategoryTheory.Iso.toEquiv",
"DivInvMonoid.toMonoid",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"Equiv.Perm",
... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 572,
"column": 21
} | {
"line": 572,
"column": 26
} | {
"line": 573,
"column": 6
} | [
{
"pp": "α : Type u\n⊢ Iso.toEquiv 1 = 1",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Monoid.toMulOneClass",
"CategoryTheory.Iso.toEquiv",
"DivInvMonoid.toMonoid",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"Equiv.Perm",
... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 572,
"column": 21
} | {
"line": 572,
"column": 26
} | {
"line": 573,
"column": 6
} | [
{
"pp": "α : Type u\n⊢ Iso.toEquiv 1 = 1",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Monoid.toMulOneClass",
"CategoryTheory.Iso.toEquiv",
"DivInvMonoid.toMonoid",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"Equiv.Perm",
... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 573,
"column": 21
} | {
"line": 573,
"column": 26
} | {
"line": 573,
"column": 27
} | [
{
"pp": "α : Type u\n⊢ ∀ (x y : Aut α), Iso.toEquiv (x * y) = Iso.toEquiv x * Iso.toEquiv y",
"ppTerm": "?m.40",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"CategoryTheory.Iso.toEquiv",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"Group... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 573,
"column": 21
} | {
"line": 573,
"column": 26
} | {
"line": 573,
"column": 27
} | [
{
"pp": "α : Type u\n⊢ ∀ (x y : Aut α), Iso.toEquiv (x * y) = Iso.toEquiv x * Iso.toEquiv y",
"ppTerm": "?m.40",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"CategoryTheory.Iso.toEquiv",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"Group... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 573,
"column": 21
} | {
"line": 573,
"column": 26
} | {
"line": 573,
"column": 27
} | [
{
"pp": "α : Type u\n⊢ ∀ (x y : Aut α), Iso.toEquiv (x * y) = Iso.toEquiv x * Iso.toEquiv y",
"ppTerm": "?m.40",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"CategoryTheory.Iso.toEquiv",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"Group... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 576,
"column": 21
} | {
"line": 576,
"column": 26
} | {
"line": 577,
"column": 6
} | [
{
"pp": "α : Type u\n⊢ Equiv.toIso 1 = 1",
"ppTerm": "?m.41",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Monoid.toMulOneClass",
"DivInvMonoid.toMonoid",
"Equiv.toIso",
"Group.toDivInvMonoid",
"Equiv.Perm.permGroup",
"MulOneClass.toMulOne",
"... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 576,
"column": 21
} | {
"line": 576,
"column": 26
} | {
"line": 577,
"column": 6
} | [
{
"pp": "α : Type u\n⊢ Equiv.toIso 1 = 1",
"ppTerm": "?m.41",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Monoid.toMulOneClass",
"DivInvMonoid.toMonoid",
"Equiv.toIso",
"Group.toDivInvMonoid",
"Equiv.Perm.permGroup",
"MulOneClass.toMulOne",
"... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 576,
"column": 21
} | {
"line": 576,
"column": 26
} | {
"line": 577,
"column": 6
} | [
{
"pp": "α : Type u\n⊢ Equiv.toIso 1 = 1",
"ppTerm": "?m.41",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Monoid.toMulOneClass",
"DivInvMonoid.toMonoid",
"Equiv.toIso",
"Group.toDivInvMonoid",
"Equiv.Perm.permGroup",
"MulOneClass.toMulOne",
"... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 577,
"column": 21
} | {
"line": 577,
"column": 26
} | {
"line": 577,
"column": 27
} | [
{
"pp": "α : Type u\n⊢ ∀ (x y : Equiv.Perm α), Equiv.toIso (x * y) = Equiv.toIso x * Equiv.toIso y",
"ppTerm": "?m.42",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"Equiv.toIso",
"Group.toDivIn... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 577,
"column": 21
} | {
"line": 577,
"column": 26
} | {
"line": 577,
"column": 27
} | [
{
"pp": "α : Type u\n⊢ ∀ (x y : Equiv.Perm α), Equiv.toIso (x * y) = Equiv.toIso x * Equiv.toIso y",
"ppTerm": "?m.42",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"Equiv.toIso",
"Group.toDivIn... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 577,
"column": 21
} | {
"line": 577,
"column": 26
} | {
"line": 577,
"column": 27
} | [
{
"pp": "α : Type u\n⊢ ∀ (x y : Equiv.Perm α), Equiv.toIso (x * y) = Equiv.toIso x * Equiv.toIso y",
"ppTerm": "?m.42",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"Equiv.toIso",
"Group.toDivIn... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Adjunction.Basic | {
"line": 192,
"column": 67
} | {
"line": 192,
"column": 72
} | {
"line": 193,
"column": 2
} | [
{
"pp": "case mk.mk\nC : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nF : C ⥤ D\nG : D ⥤ C\nunit✝¹ : 𝟭 C ⟶ F ⋙ G\ncounit✝¹ : G ⋙ F ⟶ 𝟭 D\nleft_triangle_components✝¹ : ∀ (X : C), F.map (unit✝¹.app X) ≫ counit✝¹.app (F.obj X) = 𝟙 (F.obj X)\nright_triangle_components✝¹ : ∀ (Y... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Limits.IsLimit | {
"line": 503,
"column": 27
} | {
"line": 503,
"column": 32
} | {
"line": 503,
"column": 32
} | [
{
"pp": "J : Type u₁\ninst✝¹ : Category.{v₁, u₁} J\nC : Type u₃\ninst✝ : Category.{v₃, u₃} C\nF : J ⥤ C\nt : Cone F\nh : IsLimit t\nW W' : C\nf : (const J).obj W ⟶ F\ng : W' ⟶ W\n⊢ h.homEquiv (h.homEquiv.symm ((const J).map g ≫ f)) = h.homEquiv (g ≫ h.homEquiv.symm f)",
"ppTerm": "?m.75",
"assigned": tr... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Limits.IsLimit | {
"line": 503,
"column": 27
} | {
"line": 503,
"column": 32
} | {
"line": 503,
"column": 32
} | [
{
"pp": "J : Type u₁\ninst✝¹ : Category.{v₁, u₁} J\nC : Type u₃\ninst✝ : Category.{v₃, u₃} C\nF : J ⥤ C\nt : Cone F\nh : IsLimit t\nW W' : C\nf : (const J).obj W ⟶ F\ng : W' ⟶ W\n⊢ h.homEquiv (h.homEquiv.symm ((const J).map g ≫ f)) = h.homEquiv (g ≫ h.homEquiv.symm f)",
"ppTerm": "?m.75",
"assigned": tr... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.IsLimit | {
"line": 503,
"column": 27
} | {
"line": 503,
"column": 32
} | {
"line": 503,
"column": 32
} | [
{
"pp": "J : Type u₁\ninst✝¹ : Category.{v₁, u₁} J\nC : Type u₃\ninst✝ : Category.{v₃, u₃} C\nF : J ⥤ C\nt : Cone F\nh : IsLimit t\nW W' : C\nf : (const J).obj W ⟶ F\ng : W' ⟶ W\n⊢ h.homEquiv (h.homEquiv.symm ((const J).map g ≫ f)) = h.homEquiv (g ≫ h.homEquiv.symm f)",
"ppTerm": "?m.75",
"assigned": tr... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Adjunction.Basic | {
"line": 669,
"column": 19
} | {
"line": 669,
"column": 29
} | {
"line": 669,
"column": 30
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nF : C ⥤ D\nG : D ⥤ C\nG_obj : D → C\ne : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)\nhe : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), (e X' Y) (F.map f ≫ g) = f ≫ (e X Y) g\nY Y' Y'' : D\ng : Y ⟶ Y'\ng'... | [
"C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nF : C ⥤ D\nG : D ⥤ C\nG_obj : D → C\ne : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)\nhe : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), (e X' Y) (F.map f ≫ g) = f ≫ (e X Y) g\nY Y' Y'' : D\ng : Y ⟶ Y'\ng' : Y' ⟶ Y''\... | he'' e he, | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.CategoryTheory.Thin | {
"line": 52,
"column": 28
} | {
"line": 52,
"column": 43
} | {
"line": 52,
"column": 43
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\ninst✝ : Quiver.IsThin C\nx✝¹ x✝ : D ⥤ C\nα β : x✝¹ ⟶ x✝\n⊢ α.app = β.app",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
... | [] | by subsingleton | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Skeletal | {
"line": 129,
"column": 17
} | {
"line": 129,
"column": 22
} | {
"line": 130,
"column": 2
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nE : Type u₃\ninst✝ : Category.{v₃, u₃} E\nx✝ : C\n⊢ { hom := (fromSkeletonToSkeletonIso x✝).hom ≫ 𝟙 x✝ ≫ (fromSkeletonToSkeletonIso x✝).inv } = 𝟙 (toSkeleton x✝)",
"ppTerm": "?m.57",
"assigned": true,
"u... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Skeletal | {
"line": 129,
"column": 17
} | {
"line": 129,
"column": 22
} | {
"line": 130,
"column": 2
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nE : Type u₃\ninst✝ : Category.{v₃, u₃} E\nx✝ : C\n⊢ { hom := (fromSkeletonToSkeletonIso x✝).hom ≫ 𝟙 x✝ ≫ (fromSkeletonToSkeletonIso x✝).inv } = 𝟙 (toSkeleton x✝)",
"ppTerm": "?m.57",
"assigned": true,
"u... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Skeletal | {
"line": 129,
"column": 17
} | {
"line": 129,
"column": 22
} | {
"line": 130,
"column": 2
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nE : Type u₃\ninst✝ : Category.{v₃, u₃} E\nx✝ : C\n⊢ { hom := (fromSkeletonToSkeletonIso x✝).hom ≫ 𝟙 x✝ ≫ (fromSkeletonToSkeletonIso x✝).inv } = 𝟙 (toSkeleton x✝)",
"ppTerm": "?m.57",
"assigned": true,
"u... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.EssentiallySmall | {
"line": 310,
"column": 59
} | {
"line": 310,
"column": 64
} | {
"line": 310,
"column": 64
} | [
{
"pp": "C✝ : Type u\ninst✝³ : Category.{v, u} C✝\nA : Type u'\ninst✝² : Category.{v', u'} A\ninst✝¹ : LocallySmall.{w, v', u'} A\nC : Type w\ninst✝ : SmallCategory C\nP Q : C ⥤ A\nf g : P ⟶ Q\nh : f.app = g.app\n⊢ f = g",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"CategoryTheory... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.EssentiallySmall | {
"line": 310,
"column": 59
} | {
"line": 310,
"column": 64
} | {
"line": 310,
"column": 64
} | [
{
"pp": "C✝ : Type u\ninst✝³ : Category.{v, u} C✝\nA : Type u'\ninst✝² : Category.{v', u'} A\ninst✝¹ : LocallySmall.{w, v', u'} A\nC : Type w\ninst✝ : SmallCategory C\nP Q : C ⥤ A\nf g : P ⟶ Q\nh : f.app = g.app\n⊢ f = g",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"CategoryTheory... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.EssentiallySmall | {
"line": 310,
"column": 59
} | {
"line": 310,
"column": 64
} | {
"line": 310,
"column": 64
} | [
{
"pp": "C✝ : Type u\ninst✝³ : Category.{v, u} C✝\nA : Type u'\ninst✝² : Category.{v', u'} A\ninst✝¹ : LocallySmall.{w, v', u'} A\nC : Type w\ninst✝ : SmallCategory C\nP Q : C ⥤ A\nf g : P ⟶ Q\nh : f.app = g.app\n⊢ f = g",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"CategoryTheory... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Functor.EpiMono | {
"line": 302,
"column": 4
} | {
"line": 302,
"column": 59
} | {
"line": 304,
"column": 0
} | [
{
"pp": "C : Type u_1\nD : Type u_2\ninst✝² : Category.{v_1, u_1} C\ninst✝¹ : Category.{v_2, u_2} D\nF : C ⥤ D\nF' : D ⥤ C\nA B : C\nadj : F ⊣ F'\nX : C\nY : D\nf : F.obj X ⟶ Y\nhf : Mono ((adj.homEquiv X Y).symm ((adj.homEquiv X Y) f))\ninst✝ : F.ReflectsMonomorphisms\n⊢ Mono (F.map ((adj.homEquiv X Y) f))",
... | [] | exact mono_of_mono_fac (adj.homEquiv_counit _ _ _).symm | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Functor.EpiMono | {
"line": 317,
"column": 4
} | {
"line": 317,
"column": 37
} | {
"line": 318,
"column": 4
} | [
{
"pp": "case mp\nC : Type u_1\nD : Type u_2\ninst✝² : Category.{v_1, u_1} C\ninst✝¹ : Category.{v_2, u_2} D\nF : C ⥤ D\nA B : C\nf : A ⟶ B\ninst✝ : F.IsEquivalence\na✝ : StrongEpi (F.map f)\ne : Arrow.mk f ≅ Arrow.mk (F.inv.map (F.map f))\n⊢ StrongEpi f",
"ppTerm": "?mp",
"assigned": true,
"usedCon... | [
"case mp\nC : Type u_1\nD : Type u_2\ninst✝² : Category.{v_1, u_1} C\ninst✝¹ : Category.{v_2, u_2} D\nF : C ⥤ D\nA B : C\nf : A ⟶ B\ninst✝ : F.IsEquivalence\na✝ : StrongEpi (F.map f)\ne : Arrow.mk f ≅ Arrow.mk (F.inv.map (F.map f))\n⊢ StrongEpi (F.inv.map (F.map f))"
] | rw [StrongEpi.iff_of_arrow_iso e] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {
"line": 363,
"column": 2
} | {
"line": 363,
"column": 7
} | {
"line": 365,
"column": 0
} | [
{
"pp": "J : Type w\nC : Type u\ninst✝¹ : Category.{v, u} C\nB : C\nobjs : J → C\narrows : (j : J) → objs j ⟶ B\ninst✝ : HasWidePullback B objs arrows\nX : C\ng : X ⟶ widePullback B objs arrows\n⊢ g = lift (g ≫ base arrows) (fun j ↦ g ≫ π arrows j) ⋯",
"ppTerm": "?m.59",
"assigned": true,
"usedConst... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {
"line": 363,
"column": 2
} | {
"line": 363,
"column": 7
} | {
"line": 365,
"column": 0
} | [
{
"pp": "J : Type w\nC : Type u\ninst✝¹ : Category.{v, u} C\nB : C\nobjs : J → C\narrows : (j : J) → objs j ⟶ B\ninst✝ : HasWidePullback B objs arrows\nX : C\ng : X ⟶ widePullback B objs arrows\n⊢ g = lift (g ≫ base arrows) (fun j ↦ g ≫ π arrows j) ⋯",
"ppTerm": "?m.59",
"assigned": true,
"usedConst... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {
"line": 363,
"column": 2
} | {
"line": 363,
"column": 7
} | {
"line": 365,
"column": 0
} | [
{
"pp": "J : Type w\nC : Type u\ninst✝¹ : Category.{v, u} C\nB : C\nobjs : J → C\narrows : (j : J) → objs j ⟶ B\ninst✝ : HasWidePullback B objs arrows\nX : C\ng : X ⟶ widePullback B objs arrows\n⊢ g = lift (g ≫ base arrows) (fun j ↦ g ≫ π arrows j) ⋯",
"ppTerm": "?m.59",
"assigned": true,
"usedConst... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Products | {
"line": 1002,
"column": 5
} | {
"line": 1002,
"column": 20
} | {
"line": 1002,
"column": 20
} | [
{
"pp": "β : Type w\nα : Type w₂\nγ : Type w₃\nC : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Quiver.IsThin C\nJ : Type u_1\ninst✝ : Category.{v_1, u_1} J\nK : J ⥤ C\nc : Cone K\nhc : IsLimit c\n⊢ ∀ (s : Fan K.obj) (j : J),\n hc.lift { pt := s.pt, π := { app := fun j ↦ s.proj j, naturality := ⋯ } } ≫ (Fan.... | [] | by subsingleton | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Products | {
"line": 1002,
"column": 23
} | {
"line": 1002,
"column": 38
} | {
"line": 1002,
"column": 38
} | [
{
"pp": "β : Type w\nα : Type w₂\nγ : Type w₃\nC : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Quiver.IsThin C\nJ : Type u_1\ninst✝ : Category.{v_1, u_1} J\nK : J ⥤ C\nc : Cone K\nhc : IsLimit c\n⊢ ∀ (s : Fan K.obj) (m : s.pt ⟶ (Fan.mk c.pt c.π.app).pt),\n (∀ (j : J), m ≫ (Fan.mk c.pt c.π.app).proj j = s.pr... | [] | by subsingleton | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Products | {
"line": 1010,
"column": 5
} | {
"line": 1010,
"column": 20
} | {
"line": 1010,
"column": 20
} | [
{
"pp": "β : Type w\nα : Type w₂\nγ : Type w₃\nC : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Quiver.IsThin C\nJ : Type u_1\ninst✝ : Category.{v_1, u_1} J\nK : J ⥤ C\nc : Cocone K\nhc : IsColimit c\n⊢ ∀ (t : Cofan K.obj) (j : J),\n (Cofan.mk c.pt c.ι.app).inj j ≫ hc.desc { pt := t.pt, ι := { app := fun j ↦... | [] | by subsingleton | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Products | {
"line": 1010,
"column": 23
} | {
"line": 1010,
"column": 38
} | {
"line": 1010,
"column": 38
} | [
{
"pp": "β : Type w\nα : Type w₂\nγ : Type w₃\nC : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Quiver.IsThin C\nJ : Type u_1\ninst✝ : Category.{v_1, u_1} J\nK : J ⥤ C\nc : Cocone K\nhc : IsColimit c\n⊢ ∀ (t : Cofan K.obj) (m : (Cofan.mk c.pt c.ι.app).pt ⟶ t.pt),\n (∀ (j : J), (Cofan.mk c.pt c.ι.app).inj j ≫... | [] | by subsingleton | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1294,
"column": 66
} | {
"line": 1294,
"column": 80
} | {
"line": 1294,
"column": 80
} | [
{
"pp": "C : Type u\ninst✝⁵ : Category.{v, u} C\nD : Type u₂\ninst✝⁴ : Category.{w, u₂} D\nF : C ⥤ D\nA A' B B' : C\ninst✝³ : HasBinaryCoproduct A B\ninst✝² : HasBinaryCoproduct A' B'\ninst✝¹ : HasBinaryCoproduct (F.obj A) (F.obj B)\ninst✝ : HasBinaryCoproduct (F.obj A') (F.obj B')\nf : A ⟶ A'\ng : B ⟶ B'\n⊢ co... | [
"C : Type u\ninst✝⁵ : Category.{v, u} C\nD : Type u₂\ninst✝⁴ : Category.{w, u₂} D\nF : C ⥤ D\nA A' B B' : C\ninst✝³ : HasBinaryCoproduct A B\ninst✝² : HasBinaryCoproduct A' B'\ninst✝¹ : HasBinaryCoproduct (F.obj A) (F.obj B)\ninst✝ : HasBinaryCoproduct (F.obj A') (F.obj B')\nf : A ⟶ A'\ng : B ⟶ B'\n⊢ coprod.desc (F... | coprod.inr_map | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1412,
"column": 57
} | {
"line": 1412,
"column": 68
} | {
"line": 1412,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\nc : BinaryFan X Y\nhc : IsLimit c\ns : BinaryCofan (op X) (op Y)\nm : op (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left }) ⟶ s.pt\nh₁ : c.fst.op ≫ m = s.inl\nh₂ : c.snd.op ≫ m = s.inr\n⊢ m.unop ≫ c.snd = (hc.lift s.uno... | [] | simp [← h₂] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1412,
"column": 57
} | {
"line": 1412,
"column": 68
} | {
"line": 1412,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\nc : BinaryFan X Y\nhc : IsLimit c\ns : BinaryCofan (op X) (op Y)\nm : op (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left }) ⟶ s.pt\nh₁ : c.fst.op ≫ m = s.inl\nh₂ : c.snd.op ≫ m = s.inr\n⊢ m.unop ≫ c.snd = (hc.lift s.uno... | [] | simp [← h₂] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1412,
"column": 57
} | {
"line": 1412,
"column": 68
} | {
"line": 1412,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\nc : BinaryFan X Y\nhc : IsLimit c\ns : BinaryCofan (op X) (op Y)\nm : op (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left }) ⟶ s.pt\nh₁ : c.fst.op ≫ m = s.inl\nh₂ : c.snd.op ≫ m = s.inr\n⊢ m.unop ≫ c.snd = (hc.lift s.uno... | [] | simp [← h₂] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1420,
"column": 61
} | {
"line": 1420,
"column": 72
} | {
"line": 1420,
"column": 72
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\nc : BinaryCofan X Y\nhc : IsColimit c\ns : BinaryFan (op X) (op Y)\nm : s.pt ⟶ op (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left })\nh₁ : m ≫ c.inl.op = s.fst\nh₂ : m ≫ c.inr.op = s.snd\n⊢ c.inr ≫ m.unop = c.inr ≫ (hc.... | [] | simp [← h₂] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1420,
"column": 61
} | {
"line": 1420,
"column": 72
} | {
"line": 1420,
"column": 72
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\nc : BinaryCofan X Y\nhc : IsColimit c\ns : BinaryFan (op X) (op Y)\nm : s.pt ⟶ op (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left })\nh₁ : m ≫ c.inl.op = s.fst\nh₂ : m ≫ c.inr.op = s.snd\n⊢ c.inr ≫ m.unop = c.inr ≫ (hc.... | [] | simp [← h₂] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1420,
"column": 61
} | {
"line": 1420,
"column": 72
} | {
"line": 1420,
"column": 72
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\nc : BinaryCofan X Y\nhc : IsColimit c\ns : BinaryFan (op X) (op Y)\nm : s.pt ⟶ op (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left })\nh₁ : m ≫ c.inl.op = s.fst\nh₂ : m ≫ c.inr.op = s.snd\n⊢ c.inr ≫ m.unop = c.inr ≫ (hc.... | [] | simp [← h₂] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1429,
"column": 57
} | {
"line": 1429,
"column": 68
} | {
"line": 1429,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\nc : BinaryFan (op X) (op Y)\nhc : IsLimit c\ns : BinaryCofan X Y\nm : unop (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left }) ⟶ s.pt\nh₁ : c.fst.unop ≫ m = s.inl\nh₂ : c.snd.unop ≫ m = s.inr\n⊢ m.op ≫ c.snd = (hc.lift s... | [] | simp [← h₂] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1429,
"column": 57
} | {
"line": 1429,
"column": 68
} | {
"line": 1429,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\nc : BinaryFan (op X) (op Y)\nhc : IsLimit c\ns : BinaryCofan X Y\nm : unop (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left }) ⟶ s.pt\nh₁ : c.fst.unop ≫ m = s.inl\nh₂ : c.snd.unop ≫ m = s.inr\n⊢ m.op ≫ c.snd = (hc.lift s... | [] | simp [← h₂] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1429,
"column": 57
} | {
"line": 1429,
"column": 68
} | {
"line": 1429,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\nc : BinaryFan (op X) (op Y)\nhc : IsLimit c\ns : BinaryCofan X Y\nm : unop (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left }) ⟶ s.pt\nh₁ : c.fst.unop ≫ m = s.inl\nh₂ : c.snd.unop ≫ m = s.inr\n⊢ m.op ≫ c.snd = (hc.lift s... | [] | simp [← h₂] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1438,
"column": 61
} | {
"line": 1438,
"column": 72
} | {
"line": 1438,
"column": 72
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\nc : BinaryCofan (op X) (op Y)\nhc : IsColimit c\ns : BinaryFan X Y\nm : s.pt ⟶ unop (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left })\nh₁ : m ≫ c.inl.unop = s.fst\nh₂ : m ≫ c.inr.unop = s.snd\n⊢ c.inr ≫ m.op = c.inr ≫ ... | [] | simp [← h₂] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1438,
"column": 61
} | {
"line": 1438,
"column": 72
} | {
"line": 1438,
"column": 72
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\nc : BinaryCofan (op X) (op Y)\nhc : IsColimit c\ns : BinaryFan X Y\nm : s.pt ⟶ unop (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left })\nh₁ : m ≫ c.inl.unop = s.fst\nh₂ : m ≫ c.inr.unop = s.snd\n⊢ c.inr ≫ m.op = c.inr ≫ ... | [] | simp [← h₂] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1438,
"column": 61
} | {
"line": 1438,
"column": 72
} | {
"line": 1438,
"column": 72
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\nc : BinaryCofan (op X) (op Y)\nhc : IsColimit c\ns : BinaryFan X Y\nm : s.pt ⟶ unop (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left })\nh₁ : m ≫ c.inl.unop = s.fst\nh₂ : m ≫ c.inr.unop = s.snd\n⊢ c.inr ≫ m.op = c.inr ≫ ... | [] | simp [← h₂] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1462,
"column": 16
} | {
"line": 1462,
"column": 23
} | {
"line": 1464,
"column": 0
} | [
{
"pp": "case left\nC : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\ns : BinaryFan X Y\nt✝ : BinaryFan Y X\nI : IsLimit s\nt : Cone (pair Y X)\nm : t.pt ⟶ s.swap.pt\nh : (∀ (j : Discrete WalkingPair), m ≫ s.π.app j = (BinaryFan.swap t).π.app j) → m = I.lift (BinaryFan.swap t)\nw : m ≫ s.swap.π.app { as := Wa... | [] | exact w | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1462,
"column": 16
} | {
"line": 1462,
"column": 23
} | {
"line": 1464,
"column": 0
} | [
{
"pp": "case right\nC : Type u\ninst✝ : Category.{v, u} C\nX Y Z P : C\ns : BinaryFan X Y\nt✝ : BinaryFan Y X\nI : IsLimit s\nt : Cone (pair Y X)\nm : t.pt ⟶ s.swap.pt\nh : (∀ (j : Discrete WalkingPair), m ≫ s.π.app j = (BinaryFan.swap t).π.app j) → m = I.lift (BinaryFan.swap t)\nw : m ≫ s.swap.π.app { as := W... | [] | exact w | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {
"line": 342,
"column": 79
} | {
"line": 342,
"column": 84
} | {
"line": 342,
"column": 85
} | [
{
"pp": "case none.none.id\nC : Type u\ninst✝ : Category.{v, u} C\nW✝ X Y Z : C\nf : X ⟶ Y\ng : X ⟶ Z\nW : C\ninl : Y ⟶ W\ninr : Z ⟶ W\neq : f ≫ inl = g ≫ inr\n⊢ (span f g).map (𝟙 none) ≫ f ≫ inl = (f ≫ inl) ≫ 𝟙 W",
"ppTerm": "?none.none.id",
"assigned": true,
"usedConstants": [
"CategoryThe... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {
"line": 342,
"column": 79
} | {
"line": 342,
"column": 84
} | {
"line": 342,
"column": 85
} | [
{
"pp": "case none.some.left.init\nC : Type u\ninst✝ : Category.{v, u} C\nW✝ X Y Z : C\nf : X ⟶ Y\ng : X ⟶ Z\nW : C\ninl : Y ⟶ W\ninr : Z ⟶ W\neq : f ≫ inl = g ≫ inr\n⊢ f ≫ inl = (f ≫ inl) ≫ 𝟙 W",
"ppTerm": "?none.some.left.init",
"assigned": true,
"usedConstants": [
"CategoryTheory.CategoryS... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {
"line": 342,
"column": 79
} | {
"line": 342,
"column": 84
} | {
"line": 342,
"column": 85
} | [
{
"pp": "case none.some.right.init\nC : Type u\ninst✝ : Category.{v, u} C\nW✝ X Y Z : C\nf : X ⟶ Y\ng : X ⟶ Z\nW : C\ninl : Y ⟶ W\ninr : Z ⟶ W\neq : f ≫ inl = g ≫ inr\n⊢ g ≫ inr = (f ≫ inl) ≫ 𝟙 W",
"ppTerm": "?none.some.right.init",
"assigned": true,
"usedConstants": [
"CategoryTheory.Categor... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {
"line": 342,
"column": 79
} | {
"line": 342,
"column": 84
} | {
"line": 342,
"column": 85
} | [
{
"pp": "case some.left.some.left.id\nC : Type u\ninst✝ : Category.{v, u} C\nW✝ X Y Z : C\nf : X ⟶ Y\ng : X ⟶ Z\nW : C\ninl : Y ⟶ W\ninr : Z ⟶ W\neq : f ≫ inl = g ≫ inr\n⊢ (span f g).map (𝟙 (some WalkingPair.left)) ≫ inl = inl ≫ 𝟙 W",
"ppTerm": "?some.left.some.left.id",
"assigned": true,
"usedCon... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {
"line": 342,
"column": 79
} | {
"line": 342,
"column": 84
} | {
"line": 342,
"column": 85
} | [
{
"pp": "case some.right.some.right.id\nC : Type u\ninst✝ : Category.{v, u} C\nW✝ X Y Z : C\nf : X ⟶ Y\ng : X ⟶ Z\nW : C\ninl : Y ⟶ W\ninr : Z ⟶ W\neq : f ≫ inl = g ≫ inr\n⊢ (span f g).map (𝟙 (some WalkingPair.right)) ≫ inr = inr ≫ 𝟙 W",
"ppTerm": "?some.right.some.right.id",
"assigned": true,
"us... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 160,
"column": 2
} | {
"line": 160,
"column": 7
} | {
"line": 162,
"column": 0
} | [
{
"pp": "T : Type u₁\ninst✝ : Category.{v₁, u₁} T\nX : T\nP : Over X → Prop\n⊢ (∀ (Y : Over X), P Y) ↔ ∀ (Y : T) (f : Y ⟶ X), P (mk f)",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"CategoryTheory.Over",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Cat... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 160,
"column": 2
} | {
"line": 160,
"column": 7
} | {
"line": 162,
"column": 0
} | [
{
"pp": "T : Type u₁\ninst✝ : Category.{v₁, u₁} T\nX : T\nP : Over X → Prop\n⊢ (∀ (Y : Over X), P Y) ↔ ∀ (Y : T) (f : Y ⟶ X), P (mk f)",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"CategoryTheory.Over",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Cat... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 160,
"column": 2
} | {
"line": 160,
"column": 7
} | {
"line": 162,
"column": 0
} | [
{
"pp": "T : Type u₁\ninst✝ : Category.{v₁, u₁} T\nX : T\nP : Over X → Prop\n⊢ (∀ (Y : Over X), P Y) ↔ ∀ (Y : T) (f : Y ⟶ X), P (mk f)",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"CategoryTheory.Over",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Cat... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 747,
"column": 2
} | {
"line": 747,
"column": 7
} | {
"line": 749,
"column": 0
} | [
{
"pp": "T : Type u₁\ninst✝ : Category.{v₁, u₁} T\nX : T\nP : Under X → Prop\n⊢ (∀ (Y : Under X), P Y) ↔ ∀ (Y : T) (f : X ⟶ Y), P (mk f)",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"CategoryTheory.Comma.right",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 747,
"column": 2
} | {
"line": 747,
"column": 7
} | {
"line": 749,
"column": 0
} | [
{
"pp": "T : Type u₁\ninst✝ : Category.{v₁, u₁} T\nX : T\nP : Under X → Prop\n⊢ (∀ (Y : Under X), P Y) ↔ ∀ (Y : T) (f : X ⟶ Y), P (mk f)",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"CategoryTheory.Comma.right",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 747,
"column": 2
} | {
"line": 747,
"column": 7
} | {
"line": 749,
"column": 0
} | [
{
"pp": "T : Type u₁\ninst✝ : Category.{v₁, u₁} T\nX : T\nP : Under X → Prop\n⊢ (∀ (Y : Under X), P Y) ↔ ∀ (Y : T) (f : X ⟶ Y), P (mk f)",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"CategoryTheory.Comma.right",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | {
"line": 182,
"column": 18
} | {
"line": 182,
"column": 33
} | {
"line": 182,
"column": 34
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nx✝ : Discrete PUnit.{u_1 + 1}\n⊢ ∀ (a : { as := PUnit.unit } ⟶ { as := PUnit.unit }), a = 𝟙 { as := PUnit.unit }",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"CategoryTheory.CategoryStruct.... | [] | by subsingleton | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | {
"line": 185,
"column": 18
} | {
"line": 185,
"column": 33
} | {
"line": 185,
"column": 34
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nx✝ : Discrete PUnit.{u_1 + 1}\n⊢ ∀ (a : { as := PUnit.unit } ⟶ { as := PUnit.unit }), a = 𝟙 { as := PUnit.unit }",
"ppTerm": "?m.40",
"assigned": true,
"usedConstants": [
"CategoryTheory.CategoryStruct.... | [] | by subsingleton | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Images | {
"line": 596,
"column": 6
} | {
"line": 596,
"column": 20
} | {
"line": 596,
"column": 20
} | [
{
"pp": "C : Type u\ninst✝⁴ : Category.{v, u} C\nX Y : C\nf : X ⟶ Y\nZ : C\ng : Y ⟶ Z\nW : C\nh : Z ⟶ W\ninst✝³ : HasImage (g ≫ h)\ninst✝² : HasImage (f ≫ g ≫ h)\ninst✝¹ : HasImage h\ninst✝ : HasImage ((f ≫ g) ≫ h)\n⊢ ι (f ≫ g ≫ h) =\n lift { I := image ((f ≫ g) ≫ h), m := ι ((f ≫ g) ≫ h), m_mono := ⋯, e := ... | [
"C : Type u\ninst✝⁴ : Category.{v, u} C\nX Y : C\nf : X ⟶ Y\nZ : C\ng : Y ⟶ Z\nW : C\nh : Z ⟶ W\ninst✝³ : HasImage (g ≫ h)\ninst✝² : HasImage (f ≫ g ≫ h)\ninst✝¹ : HasImage h\ninst✝ : HasImage ((f ≫ g) ≫ h)\n⊢ ι (f ≫ g ≫ h) = ι (f ≫ g ≫ h)"
] | image.lift_fac | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 530,
"column": 28
} | {
"line": 530,
"column": 33
} | {
"line": 530,
"column": 34
} | [
{
"pp": "C : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\nt : Fork f g\nlift : (s : Fork f g) → s.pt ⟶ t.pt\nfac : ∀ (s : Fork f g), lift s ≫ t.ι = s.ι\nuniq : ∀ (s : Fork f g) (m : s.pt ⟶ t.pt), m ≫ t.ι = s.ι → m = lift s\ns : Cone (parallelPair f g)\nm : s.pt ⟶ t.pt\nj : ∀ (j : WalkingParallelPair... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 530,
"column": 28
} | {
"line": 530,
"column": 33
} | {
"line": 530,
"column": 34
} | [
{
"pp": "C : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\nt : Fork f g\nlift : (s : Fork f g) → s.pt ⟶ t.pt\nfac : ∀ (s : Fork f g), lift s ≫ t.ι = s.ι\nuniq : ∀ (s : Fork f g) (m : s.pt ⟶ t.pt), m ≫ t.ι = s.ι → m = lift s\ns : Cone (parallelPair f g)\nm : s.pt ⟶ t.pt\nj : ∀ (j : WalkingParallelPair... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 530,
"column": 28
} | {
"line": 530,
"column": 33
} | {
"line": 530,
"column": 34
} | [
{
"pp": "C : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\nt : Fork f g\nlift : (s : Fork f g) → s.pt ⟶ t.pt\nfac : ∀ (s : Fork f g), lift s ≫ t.ι = s.ι\nuniq : ∀ (s : Fork f g) (m : s.pt ⟶ t.pt), m ≫ t.ι = s.ι → m = lift s\ns : Cone (parallelPair f g)\nm : s.pt ⟶ t.pt\nj : ∀ (j : WalkingParallelPair... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 548,
"column": 15
} | {
"line": 548,
"column": 20
} | {
"line": 548,
"column": 21
} | [
{
"pp": "C : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\nt : Cofork f g\ndesc : (s : Cofork f g) → t.pt ⟶ s.pt\nfac : ∀ (s : Cofork f g), t.π ≫ desc s = s.π\nuniq : ∀ (s : Cofork f g) (m : t.pt ⟶ s.pt), t.π ≫ m = s.π → m = desc s\n⊢ ∀ (s : Cocone (parallelPair f g)) (m : t.pt ⟶ s.pt),\n (∀ (j : ... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 548,
"column": 15
} | {
"line": 548,
"column": 20
} | {
"line": 548,
"column": 21
} | [
{
"pp": "C : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\nt : Cofork f g\ndesc : (s : Cofork f g) → t.pt ⟶ s.pt\nfac : ∀ (s : Cofork f g), t.π ≫ desc s = s.π\nuniq : ∀ (s : Cofork f g) (m : t.pt ⟶ s.pt), t.π ≫ m = s.π → m = desc s\n⊢ ∀ (s : Cocone (parallelPair f g)) (m : t.pt ⟶ s.pt),\n (∀ (j : ... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 548,
"column": 15
} | {
"line": 548,
"column": 20
} | {
"line": 548,
"column": 21
} | [
{
"pp": "C : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\nt : Cofork f g\ndesc : (s : Cofork f g) → t.pt ⟶ s.pt\nfac : ∀ (s : Cofork f g), t.π ≫ desc s = s.π\nuniq : ∀ (s : Cofork f g) (m : t.pt ⟶ s.pt), t.π ≫ m = s.π → m = desc s\n⊢ ∀ (s : Cocone (parallelPair f g)) (m : t.pt ⟶ s.pt),\n (∀ (j : ... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 694,
"column": 6
} | {
"line": 694,
"column": 13
} | {
"line": 695,
"column": 4
} | [
{
"pp": "case zero\nC : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\ns t : Fork f g\nk : s.pt ⟶ t.pt\nw : k ≫ t.ι = s.ι\n⊢ k ≫ t.π.app zero = s.π.app zero",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [],
"usedFVars": [
"w"
],
"usedGoals": []
}
] | [] | exact w | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 694,
"column": 6
} | {
"line": 694,
"column": 13
} | {
"line": 695,
"column": 4
} | [
{
"pp": "case zero\nC : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\ns t : Fork f g\nk : s.pt ⟶ t.pt\nw : k ≫ t.ι = s.ι\n⊢ k ≫ t.π.app zero = s.π.app zero",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [],
"usedFVars": [
"w"
],
"usedGoals": []
}
] | [] | exact w | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 694,
"column": 6
} | {
"line": 694,
"column": 13
} | {
"line": 695,
"column": 4
} | [
{
"pp": "case zero\nC : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\ns t : Fork f g\nk : s.pt ⟶ t.pt\nw : k ≫ t.ι = s.ι\n⊢ k ≫ t.π.app zero = s.π.app zero",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [],
"usedFVars": [
"w"
],
"usedGoals": []
}
] | [] | exact w | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 433,
"column": 4
} | {
"line": 433,
"column": 39
} | {
"line": 434,
"column": 4
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nD : Type u'\ninst✝¹ : Category.{v', u'} D\ninst✝ : HasZeroMorphisms C\nX Y : C\ni : IsIso 0\n⊢ 0 ≫ inv 0 = 0 ∧ 𝟙 Y = 0",
"ppTerm": "?m.51",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Qu... | [
"C : Type u\ninst✝² : Category.{v, u} C\nD : Type u'\ninst✝¹ : Category.{v', u'} D\ninst✝ : HasZeroMorphisms C\nX Y : C\ni : IsIso 0\n⊢ 0 ≫ inv 0 = 0 ∧ inv 0 ≫ 0 = 0"
] | rw [← IsIso.inv_hom_id (0 : X ⟶ Y)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 783,
"column": 6
} | {
"line": 783,
"column": 13
} | {
"line": 785,
"column": 0
} | [
{
"pp": "case one\nC : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\ns t : Cofork f g\nk : s.pt ⟶ t.pt\nw : s.π ≫ k = t.π\n⊢ s.ι.app one ≫ k = t.ι.app one",
"ppTerm": "?one",
"assigned": true,
"usedConstants": [],
"usedFVars": [
"w"
],
"usedGoals": []
}
] | [] | exact w | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 783,
"column": 6
} | {
"line": 783,
"column": 13
} | {
"line": 785,
"column": 0
} | [
{
"pp": "case one\nC : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\ns t : Cofork f g\nk : s.pt ⟶ t.pt\nw : s.π ≫ k = t.π\n⊢ s.ι.app one ≫ k = t.ι.app one",
"ppTerm": "?one",
"assigned": true,
"usedConstants": [],
"usedFVars": [
"w"
],
"usedGoals": []
}
] | [] | exact w | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 783,
"column": 6
} | {
"line": 783,
"column": 13
} | {
"line": 785,
"column": 0
} | [
{
"pp": "case one\nC : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\ns t : Cofork f g\nk : s.pt ⟶ t.pt\nw : s.π ≫ k = t.π\n⊢ s.ι.app one ≫ k = t.ι.app one",
"ppTerm": "?one",
"assigned": true,
"usedConstants": [],
"usedFVars": [
"w"
],
"usedGoals": []
}
] | [] | exact w | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 787,
"column": 29
} | {
"line": 787,
"column": 34
} | {
"line": 789,
"column": 0
} | [
{
"pp": "case mk.mk.mk\nC : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\npt✝¹ : C\nπ✝¹ : (Functor.const WalkingParallelPair).obj pt✝¹ ⟶ parallelPair f g\npt✝ : C\nπ✝ : (Functor.const WalkingParallelPair).obj pt✝ ⟶ parallelPair f g\nhom✝ : { pt := pt✝¹, π := π✝¹ }.pt ⟶ { pt := pt✝, π := π✝ }.pt\nw✝ :... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 791,
"column": 29
} | {
"line": 791,
"column": 34
} | {
"line": 793,
"column": 0
} | [
{
"pp": "case mk.mk.mk\nC : Type u\nX Y : C\ninst✝ : Category.{v, u} C\nf g : X ⟶ Y\npt✝¹ : C\nι✝¹ : parallelPair f g ⟶ (Functor.const WalkingParallelPair).obj pt✝¹\npt✝ : C\nι✝ : parallelPair f g ⟶ (Functor.const WalkingParallelPair).obj pt✝\nhom✝ : { pt := pt✝¹, ι := ι✝¹ }.pt ⟶ { pt := pt✝, ι := ι✝ }.pt\nw✝ :... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Algebra.Category.ModuleCat.Semi | {
"line": 267,
"column": 47
} | {
"line": 267,
"column": 52
} | {
"line": 267,
"column": 52
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\nX₁ X₂ : Type v\nX Y : SemimoduleCat R\ni : X ≅ Y\n⊢ Hom.hom i.hom ∘ₗ Hom.hom i.inv = LinearMap.id",
"ppTerm": "?m.49",
"assigned": true,
"usedConstants": [
"SemimoduleCat.isModule",
"LinearMap.id",
"SemimoduleCat.moduleCategory",
"Semi... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Algebra.Category.ModuleCat.Semi | {
"line": 267,
"column": 47
} | {
"line": 267,
"column": 52
} | {
"line": 267,
"column": 52
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\nX₁ X₂ : Type v\nX Y : SemimoduleCat R\ni : X ≅ Y\n⊢ Hom.hom i.hom ∘ₗ Hom.hom i.inv = LinearMap.id",
"ppTerm": "?m.49",
"assigned": true,
"usedConstants": [
"SemimoduleCat.isModule",
"LinearMap.id",
"SemimoduleCat.moduleCategory",
"Semi... | [] | aesop | 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.