module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.CategoryTheory.Abelian.SerreClass.Localization | {
"line": 330,
"column": 32
} | {
"line": 330,
"column": 56
} | [
{
"pp": "C : Type u\ninst✝⁶ : Category.{v, u} C\ninst✝⁵ : Abelian C\nD : Type u'\ninst✝⁴ : Category.{v', u'} D\nL : C ⥤ D\nP : ObjectProperty C\ninst✝³ : P.IsSerreClass\ninst✝² : L.IsLocalization P.isoModSerre\ninst✝¹ : Preadditive D\ninst✝ : L.Additive\nX Y : C\nf : X ⟶ Y\nthis✝¹ : L.PreservesEpimorphisms\nthi... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Abelian.SerreClass.Localization | {
"line": 523,
"column": 6
} | {
"line": 523,
"column": 50
} | [
{
"pp": "C : Type u\ninst✝⁸ : Category.{v, u} C\ninst✝⁷ : Abelian C\nD : Type u'\ninst✝⁶ : Category.{v', u'} D\nL : C ⥤ D\nP : ObjectProperty C\ninst✝⁵ : P.IsSerreClass\nE : Type u''\ninst✝⁴ : Category.{v'', u''} E\ninst✝³ : Abelian E\ninst✝² : L.IsLocalization P.isoModSerre\ninst✝¹ : Preadditive D\ninst✝ : L.A... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Monad.Coequalizer | {
"line": 72,
"column": 4
} | {
"line": 72,
"column": 36
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nT : Monad C\nX : T.Algebra\n⊢ T.free.obj X.A ⟶ T.free.obj (T.obj X.A)",
"usedConstants": [
"CategoryTheory.Functor.id",
"CategoryTheory.Monad.Algebra.A",
"CategoryTheory.Functor.map",
"CategoryTheory.Monad.toFunctor",
"Category... | apply (free T).map (T.η.app X.A) | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.CategoryTheory.Monad.Coequalizer | {
"line": 72,
"column": 4
} | {
"line": 72,
"column": 36
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nT : Monad C\nX : T.Algebra\n⊢ T.free.obj X.A ⟶ T.free.obj (T.obj X.A)",
"usedConstants": [
"CategoryTheory.Functor.id",
"CategoryTheory.Monad.Algebra.A",
"CategoryTheory.Functor.map",
"CategoryTheory.Monad.toFunctor",
"Category... | apply (free T).map (T.η.app X.A) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Monad.Coequalizer | {
"line": 72,
"column": 4
} | {
"line": 72,
"column": 36
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nT : Monad C\nX : T.Algebra\n⊢ T.free.obj X.A ⟶ T.free.obj (T.obj X.A)",
"usedConstants": [
"CategoryTheory.Functor.id",
"CategoryTheory.Monad.Algebra.A",
"CategoryTheory.Functor.map",
"CategoryTheory.Monad.toFunctor",
"Category... | apply (free T).map (T.η.app X.A) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monad.Coequalizer | {
"line": 100,
"column": 6
} | {
"line": 100,
"column": 61
} | [
{
"pp": "case refine_2.h\nC : Type u₁\ninst✝ : Category.{v₁, u₁} C\nT : Monad C\nX : T.Algebra\ns : Cofork (FreeCoequalizer.topMap X) (FreeCoequalizer.bottomMap X)\nh₁ : T.map X.a ≫ s.π.f = T.μ.app X.A ≫ s.π.f\nh₂ : T.map s.π.f ≫ s.pt.a = T.μ.app X.A ≫ s.π.f\n⊢ ((beckAlgebraCofork X).π ≫ { f := T.η.app (beckAlg... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Action.Monoidal | {
"line": 281,
"column": 6
} | {
"line": 282,
"column": 28
} | [
{
"pp": "case succ.h.succ\nG : Type u\ninst✝ : Group G\nn : ℕ\nhn :\n ∀ (g : G) (f : Fin n → G),\n (ConcreteCategory.hom (diagonalSuccIsoTensorTrivial G n).inv.hom) (g, f) = g • Fin.partialProd f\ng : G\nf : Fin (n + 1) → G\ni : Fin (n + 1)\n⊢ (ConcreteCategory.hom (diagonalSuccIsoTensorTrivial G (n + 1)).i... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Adjunction.Triple | {
"line": 92,
"column": 6
} | {
"line": 93,
"column": 20
} | [
{
"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\nG : D ⥤ C\nH : C ⥤ D\nt : Triple F G H\nh : H.FullyFaithful\nthis✝ : H.Full\nthis : H.Faithful\n⊢ IsIso t.adj₁.unit",
"usedConstants": [
"CategoryTheory.Adjunction.Triple.isIso_unit_iff_isIso... | rw [t.isIso_unit_iff_isIso_counit]
infer_instance | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Adjunction.Triple | {
"line": 92,
"column": 6
} | {
"line": 93,
"column": 20
} | [
{
"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\nG : D ⥤ C\nH : C ⥤ D\nt : Triple F G H\nh : H.FullyFaithful\nthis✝ : H.Full\nthis : H.Faithful\n⊢ IsIso t.adj₁.unit",
"usedConstants": [
"CategoryTheory.Adjunction.Triple.isIso_unit_iff_isIso... | rw [t.isIso_unit_iff_isIso_counit]
infer_instance | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Action.Monoidal | {
"line": 351,
"column": 24
} | {
"line": 351,
"column": 32
} | [
{
"pp": "case h\nV : Type u_1\ninst✝⁵ : Category.{v_1, u_1} V\nG : Type u_2\ninst✝⁴ : Monoid G\nW : Type u_3\ninst✝³ : Category.{v_2, u_3} W\ninst✝² : MonoidalCategory V\ninst✝¹ : MonoidalCategory W\nF : V ⥤ W\ninst✝ : F.Monoidal\n⊢ ε F ≫ η F = 𝟙 (𝟙_ W)",
"usedConstants": [
"Eq.mpr",
"Category... | rw [ε_η] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Adjunction.Triple | {
"line": 192,
"column": 2
} | {
"line": 192,
"column": 13
} | [
{
"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\nG : D ⥤ C\nH : C ⥤ D\nt : Triple F G H\ninst✝² : G.Full\ninst✝¹ : G.Faithful\ninst✝ : H.PreservesEpimorphisms\nX : C\nx✝ : G.IsLeftAdjoint\nh : Epi (t.adj₂.counit.app X ≫ t.adj₁.unit.app X)\n⊢ Epi (H.... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Adjunction.Triple | {
"line": 240,
"column": 2
} | {
"line": 240,
"column": 13
} | [
{
"pp": "case e_a.e_a\nC : Type u_1\nD : Type u_2\ninst✝³ : Category.{v_1, u_1} C\ninst✝² : Category.{v_2, u_2} D\nF : C ⥤ D\nG : D ⥤ C\nH : C ⥤ D\nt : Triple F G H\ninst✝¹ : F.Full\ninst✝ : F.Faithful\nX : D\n⊢ G.map (t.adj₁.counit.app X) ≫ 𝟙 (G.obj X) = inv (t.adj₁.unit.app (G.obj X))",
"usedConstants": ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Adjunction.Quadruple | {
"line": 128,
"column": 2
} | {
"line": 128,
"column": 13
} | [
{
"pp": "C : Type u₁\nD : Type u₂\ninst✝⁵ : Category.{v₁, u₁} C\ninst✝⁴ : Category.{v₂, u₂} D\nL : C ⥤ D\nF : D ⥤ C\nG : C ⥤ D\nR : D ⥤ C\nq : Quadruple L F G R\ninst✝³ : L.Full\ninst✝² : L.Faithful\ninst✝¹ : G.Full\ninst✝ : G.Faithful\nh :\n (∀ (a : D), Epi (q.op.leftTriple.rightToLeft.app (Opposite.equivToOp... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Adjunction.Triple | {
"line": 300,
"column": 2
} | {
"line": 300,
"column": 13
} | [
{
"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\nG : D ⥤ C\nH : C ⥤ D\nt : Triple F G H\ninst✝¹ : F.Full\ninst✝ : F.Faithful\nh : ∀ (X : D), Mono (t.adj₁.counit.app X ≫ t.adj₂.unit.app X)\nX : C\n⊢ Mono (t.adj₂.unit.app (F.obj X))",
"usedConstan... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case vcomp_right\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝¹ b✝ : B\nf✝ g✝ h✝ : Hom a✝¹ b✝\nη✝ : Hom₂ f✝ g✝\nθ₁✝ θ₂✝ : Hom₂ g✝ h✝\na✝ : Rel θ₁✝ θ₂✝\na_ih✝ : liftHom₂ F θ₁✝ = liftHom₂ F θ₂✝\n⊢ liftHom₂ F (η✝.vco... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case vcomp_right\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝¹ b✝ : B\nf✝ g✝ h✝ : Hom a✝¹ b✝\nη✝ : Hom₂ f✝ g✝\nθ₁✝ θ₂✝ : Hom₂ g✝ h✝\na✝ : Rel θ₁✝ θ₂✝\na_ih✝ : liftHom₂ F θ₁✝ = liftHom₂ F θ₂✝\n⊢ liftHom₂ F (η✝.vco... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case vcomp_left\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝¹ b✝ : B\nf✝ g✝ h✝ : Hom a✝¹ b✝\nη₁✝ η₂✝ : Hom₂ f✝ g✝\nθ✝ : Hom₂ g✝ h✝\na✝ : Rel η₁✝ η₂✝\na_ih✝ : liftHom₂ F η₁✝ = liftHom₂ F η₂✝\n⊢ liftHom₂ F (η₁✝.vco... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case vcomp_left\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝¹ b✝ : B\nf✝ g✝ h✝ : Hom a✝¹ b✝\nη₁✝ η₂✝ : Hom₂ f✝ g✝\nθ✝ : Hom₂ g✝ h✝\na✝ : Rel η₁✝ η₂✝\na_ih✝ : liftHom₂ F η₁✝ = liftHom₂ F η₂✝\n⊢ liftHom₂ F (η₁✝.vco... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case id_comp\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ g✝ : Hom a✝ b✝\nη✝ : Hom₂ f✝ g✝\n⊢ liftHom₂ F ((Hom₂.id f✝).vcomp η✝) = liftHom₂ F η✝",
"usedConstants": [
"CategoryTheory.FreeBicate... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case id_comp\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ g✝ : Hom a✝ b✝\nη✝ : Hom₂ f✝ g✝\n⊢ liftHom₂ F ((Hom₂.id f✝).vcomp η✝) = liftHom₂ F η✝",
"usedConstants": [
"CategoryTheory.FreeBicate... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case comp_id\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ g✝ : Hom a✝ b✝\nη✝ : Hom₂ f✝ g✝\n⊢ liftHom₂ F (η✝.vcomp (Hom₂.id g✝)) = liftHom₂ F η✝",
"usedConstants": [
"CategoryTheory.FreeBicate... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case comp_id\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ g✝ : Hom a✝ b✝\nη✝ : Hom₂ f✝ g✝\n⊢ liftHom₂ F (η✝.vcomp (Hom₂.id g✝)) = liftHom₂ F η✝",
"usedConstants": [
"CategoryTheory.FreeBicate... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case assoc\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ g✝ h✝ i✝ : Hom a✝ b✝\nη✝ : Hom₂ f✝ g✝\nθ✝ : Hom₂ g✝ h✝\nι✝ : Hom₂ h✝ i✝\n⊢ liftHom₂ F ((η✝.vcomp θ✝).vcomp ι✝) = liftHom₂ F (η✝.vcomp (θ✝.vcomp ι... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case assoc\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ g✝ h✝ i✝ : Hom a✝ b✝\nη✝ : Hom₂ f✝ g✝\nθ✝ : Hom₂ g✝ h✝\nι✝ : Hom₂ h✝ i✝\n⊢ liftHom₂ F ((η✝.vcomp θ✝).vcomp ι✝) = liftHom₂ F (η✝.vcomp (θ✝.vcomp ι... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_left\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝¹ b✝ c✝ : B\nf✝ : Hom a✝¹ b✝\ng✝ h✝ : Hom b✝ c✝\nη✝ η'✝ : Hom₂ g✝ h✝\na✝ : Rel η✝ η'✝\na_ih✝ : liftHom₂ F η✝ = liftHom₂ F η'✝\n⊢ liftHom₂ F (Hom₂.whis... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_left\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝¹ b✝ c✝ : B\nf✝ : Hom a✝¹ b✝\ng✝ h✝ : Hom b✝ c✝\nη✝ η'✝ : Hom₂ g✝ h✝\na✝ : Rel η✝ η'✝\na_ih✝ : liftHom₂ F η✝ = liftHom₂ F η'✝\n⊢ liftHom₂ F (Hom₂.whis... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_left_id\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\n⊢ liftHom₂ F (Hom₂.whisker_left f✝ (Hom₂.id g✝)) = liftHom₂ F (Hom₂.id (f✝.comp g✝))",
"usedConstan... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_left_id\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\n⊢ liftHom₂ F (Hom₂.whisker_left f✝ (Hom₂.id g✝)) = liftHom₂ F (Hom₂.id (f✝.comp g✝))",
"usedConstan... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_left_comp\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ : B\nf✝ : Hom a✝ b✝\ng✝ h✝ i✝ : Hom b✝ c✝\nη✝ : Hom₂ g✝ h✝\nθ✝ : Hom₂ h✝ i✝\n⊢ liftHom₂ F (Hom₂.whisker_left f✝ (η✝.vcomp θ✝)) =\n lift... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_left_comp\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ : B\nf✝ : Hom a✝ b✝\ng✝ h✝ i✝ : Hom b✝ c✝\nη✝ : Hom₂ g✝ h✝\nθ✝ : Hom₂ h✝ i✝\n⊢ liftHom₂ F (Hom₂.whisker_left f✝ (η✝.vcomp θ✝)) =\n lift... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case id_whisker_left\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ g✝ : Hom a✝ b✝\nη✝ : Hom₂ f✝ g✝\n⊢ liftHom₂ F (Hom₂.whisker_left (Hom.id a✝) η✝) =\n liftHom₂ F ((Hom₂.left_unitor f✝).vcomp (η✝.vco... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case id_whisker_left\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ g✝ : Hom a✝ b✝\nη✝ : Hom₂ f✝ g✝\n⊢ liftHom₂ F (Hom₂.whisker_left (Hom.id a✝) η✝) =\n liftHom₂ F ((Hom₂.left_unitor f✝).vcomp (η✝.vco... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case comp_whisker_left\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ d✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\nh✝ h'✝ : Hom c✝ d✝\nη✝ : Hom₂ h✝ h'✝\n⊢ liftHom₂ F (Hom₂.whisker_left (f✝.comp g✝) η✝) =\n lift... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case comp_whisker_left\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ d✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\nh✝ h'✝ : Hom c✝ d✝\nη✝ : Hom₂ h✝ h'✝\n⊢ liftHom₂ F (Hom₂.whisker_left (f✝.comp g✝) η✝) =\n lift... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_right\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝¹ b✝ c✝ : B\nf✝ g✝ : Hom a✝¹ b✝\nh✝ : Hom b✝ c✝\nη✝ η'✝ : Hom₂ f✝ g✝\na✝ : Rel η✝ η'✝\na_ih✝ : liftHom₂ F η✝ = liftHom₂ F η'✝\n⊢ liftHom₂ F (Hom₂.whi... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_right\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝¹ b✝ c✝ : B\nf✝ g✝ : Hom a✝¹ b✝\nh✝ : Hom b✝ c✝\nη✝ η'✝ : Hom₂ f✝ g✝\na✝ : Rel η✝ η'✝\na_ih✝ : liftHom₂ F η✝ = liftHom₂ F η'✝\n⊢ liftHom₂ F (Hom₂.whi... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case id_whisker_right\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\n⊢ liftHom₂ F (Hom₂.whisker_right g✝ (Hom₂.id f✝)) = liftHom₂ F (Hom₂.id (f✝.comp g✝))",
"usedConst... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case id_whisker_right\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\n⊢ liftHom₂ F (Hom₂.whisker_right g✝ (Hom₂.id f✝)) = liftHom₂ F (Hom₂.id (f✝.comp g✝))",
"usedConst... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case comp_whisker_right\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ : B\nf✝ g✝ h✝ : Hom a✝ b✝\ni✝ : Hom b✝ c✝\nη✝ : Hom₂ f✝ g✝\nθ✝ : Hom₂ g✝ h✝\n⊢ liftHom₂ F (Hom₂.whisker_right i✝ (η✝.vcomp θ✝)) =\n li... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case comp_whisker_right\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ : B\nf✝ g✝ h✝ : Hom a✝ b✝\ni✝ : Hom b✝ c✝\nη✝ : Hom₂ f✝ g✝\nθ✝ : Hom₂ g✝ h✝\n⊢ liftHom₂ F (Hom₂.whisker_right i✝ (η✝.vcomp θ✝)) =\n li... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_right_id\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ g✝ : Hom a✝ b✝\nη✝ : Hom₂ f✝ g✝\n⊢ liftHom₂ F (Hom₂.whisker_right (Hom.id b✝) η✝) =\n liftHom₂ F ((Hom₂.right_unitor f✝).vcomp (η✝.... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_right_id\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ g✝ : Hom a✝ b✝\nη✝ : Hom₂ f✝ g✝\n⊢ liftHom₂ F (Hom₂.whisker_right (Hom.id b✝) η✝) =\n liftHom₂ F ((Hom₂.right_unitor f✝).vcomp (η✝.... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_right_comp\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ d✝ : B\nf✝ f'✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\nh✝ : Hom c✝ d✝\nη✝ : Hom₂ f✝ f'✝\n⊢ liftHom₂ F (Hom₂.whisker_right (g✝.comp h✝) η✝) =\n li... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_right_comp\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ d✝ : B\nf✝ f'✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\nh✝ : Hom c✝ d✝\nη✝ : Hom₂ f✝ f'✝\n⊢ liftHom₂ F (Hom₂.whisker_right (g✝.comp h✝) η✝) =\n li... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_assoc\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ d✝ : B\nf✝ : Hom a✝ b✝\ng✝ g'✝ : Hom b✝ c✝\nη✝ : Hom₂ g✝ g'✝\nh✝ : Hom c✝ d✝\n⊢ liftHom₂ F (Hom₂.whisker_right h✝ (Hom₂.whisker_left f✝ η✝)) =... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_assoc\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ d✝ : B\nf✝ : Hom a✝ b✝\ng✝ g'✝ : Hom b✝ c✝\nη✝ : Hom₂ g✝ g'✝\nh✝ : Hom c✝ d✝\n⊢ liftHom₂ F (Hom₂.whisker_right h✝ (Hom₂.whisker_left f✝ η✝)) =... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_exchange\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ : B\nf✝ g✝ : Hom a✝ b✝\nh✝ i✝ : Hom b✝ c✝\nη✝ : Hom₂ f✝ g✝\nθ✝ : Hom₂ h✝ i✝\n⊢ liftHom₂ F ((Hom₂.whisker_left f✝ θ✝).vcomp (Hom₂.whisker_ri... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case whisker_exchange\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ : B\nf✝ g✝ : Hom a✝ b✝\nh✝ i✝ : Hom b✝ c✝\nη✝ : Hom₂ f✝ g✝\nθ✝ : Hom₂ h✝ i✝\n⊢ liftHom₂ F ((Hom₂.whisker_left f✝ θ✝).vcomp (Hom₂.whisker_ri... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case associator_hom_inv\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ d✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\nh✝ : Hom c✝ d✝\n⊢ liftHom₂ F ((Hom₂.associator f✝ g✝ h✝).vcomp (Hom₂.associator_inv f✝ g✝ h✝)) =\... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case associator_hom_inv\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ d✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\nh✝ : Hom c✝ d✝\n⊢ liftHom₂ F ((Hom₂.associator f✝ g✝ h✝).vcomp (Hom₂.associator_inv f✝ g✝ h✝)) =\... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case associator_inv_hom\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ d✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\nh✝ : Hom c✝ d✝\n⊢ liftHom₂ F ((Hom₂.associator_inv f✝ g✝ h✝).vcomp (Hom₂.associator f✝ g✝ h✝)) =\... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case associator_inv_hom\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ d✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\nh✝ : Hom c✝ d✝\n⊢ liftHom₂ F ((Hom₂.associator_inv f✝ g✝ h✝).vcomp (Hom₂.associator f✝ g✝ h✝)) =\... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case left_unitor_hom_inv\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ : Hom a✝ b✝\n⊢ liftHom₂ F ((Hom₂.left_unitor f✝).vcomp (Hom₂.left_unitor_inv f✝)) = liftHom₂ F (Hom₂.id ((Hom.id a✝).comp f✝))",
... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case left_unitor_hom_inv\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ : Hom a✝ b✝\n⊢ liftHom₂ F ((Hom₂.left_unitor f✝).vcomp (Hom₂.left_unitor_inv f✝)) = liftHom₂ F (Hom₂.id ((Hom.id a✝).comp f✝))",
... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case left_unitor_inv_hom\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ : Hom a✝ b✝\n⊢ liftHom₂ F ((Hom₂.left_unitor_inv f✝).vcomp (Hom₂.left_unitor f✝)) = liftHom₂ F (Hom₂.id f✝)",
"usedConstants": ... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case left_unitor_inv_hom\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ : Hom a✝ b✝\n⊢ liftHom₂ F ((Hom₂.left_unitor_inv f✝).vcomp (Hom₂.left_unitor f✝)) = liftHom₂ F (Hom₂.id f✝)",
"usedConstants": ... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case right_unitor_hom_inv\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ : Hom a✝ b✝\n⊢ liftHom₂ F ((Hom₂.right_unitor f✝).vcomp (Hom₂.right_unitor_inv f✝)) = liftHom₂ F (Hom₂.id (f✝.comp (Hom.id b✝)))",... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case right_unitor_hom_inv\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ : Hom a✝ b✝\n⊢ liftHom₂ F ((Hom₂.right_unitor f✝).vcomp (Hom₂.right_unitor_inv f✝)) = liftHom₂ F (Hom₂.id (f✝.comp (Hom.id b✝)))",... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case right_unitor_inv_hom\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ : Hom a✝ b✝\n⊢ liftHom₂ F ((Hom₂.right_unitor_inv f✝).vcomp (Hom₂.right_unitor f✝)) = liftHom₂ F (Hom₂.id f✝)",
"usedConstants... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case right_unitor_inv_hom\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ : B\nf✝ : Hom a✝ b✝\n⊢ liftHom₂ F ((Hom₂.right_unitor_inv f✝).vcomp (Hom₂.right_unitor f✝)) = liftHom₂ F (Hom₂.id f✝)",
"usedConstants... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case pentagon\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ d✝ e✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\nh✝ : Hom c✝ d✝\ni✝ : Hom d✝ e✝\n⊢ liftHom₂ F\n ((Hom₂.whisker_right i✝ (Hom₂.associator f✝ g✝ h✝)).... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case pentagon\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ d✝ e✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\nh✝ : Hom c✝ d✝\ni✝ : Hom d✝ e✝\n⊢ liftHom₂ F\n ((Hom₂.whisker_right i✝ (Hom₂.associator f✝ g✝ h✝)).... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case triangle\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\n⊢ liftHom₂ F ((Hom₂.associator f✝ (Hom.id b✝) g✝).vcomp (Hom₂.whisker_left f✝ (Hom₂.left_unitor g✝))) =\n l... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Free | {
"line": 322,
"column": 55
} | {
"line": 322,
"column": 82
} | [
{
"pp": "case triangle\nB : Type u₁\ninst✝¹ : Quiver B\nC : Type u₂\ninst✝ : Bicategory C\nF : B ⥤q C\na b : FreeBicategory B\nf g : a ⟶ b\nη θ : Hom₂ f g\na✝ b✝ c✝ : B\nf✝ : Hom a✝ b✝\ng✝ : Hom b✝ c✝\n⊢ liftHom₂ F ((Hom₂.associator f✝ (Hom.id b✝) g✝).vcomp (Hom₂.whisker_left f✝ (Hom₂.left_unitor g✝))) =\n l... | dsimp [liftHom₂]; cat_disch | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | {
"line": 117,
"column": 4
} | {
"line": 117,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictPseudofunctorCore B C\na✝ b✝ c✝ : B\nf : a✝ ⟶ b✝\nx✝¹ x✝ : b✝ ⟶ c✝\nη : x✝¹ ⟶ x✝\n⊢ S.map₂ (f ◁ η) = (eqToIso ⋯).hom ≫ S.map f ◁ S.map₂ η ≫ (eqToIso ⋯).inv",
"usedConstants": [
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | {
"line": 119,
"column": 4
} | {
"line": 119,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictPseudofunctorCore B C\na✝ b✝ c✝ : B\nf✝ g✝ : a✝ ⟶ b✝\nη : f✝ ⟶ g✝\nf : b✝ ⟶ c✝\n⊢ S.map₂ (η ▷ f) = (eqToIso ⋯).hom ≫ S.map₂ η ▷ S.map f ≫ (eqToIso ⋯).inv",
"usedConstants": [
"... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | {
"line": 115,
"column": 4
} | {
"line": 115,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictPseudofunctorCore B C\na✝ b✝ c✝ d✝ : B\nf : a✝ ⟶ b✝\ng : b✝ ⟶ c✝\nh : c✝ ⟶ d✝\n⊢ S.map₂ (α_ f g h).hom =\n (eqToIso ⋯).hom ≫\n (eqToIso ⋯).hom ▷ S.map h ≫ (α_ (S.map f) (S.map g)... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | {
"line": 111,
"column": 4
} | {
"line": 111,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictPseudofunctorCore B C\na✝ b✝ : B\nf : a✝ ⟶ b✝\n⊢ S.map₂ (λ_ f).hom = (eqToIso ⋯).hom ≫ (eqToIso ⋯).hom ▷ S.map f ≫ (λ_ (S.map f)).hom",
"usedConstants": [
"CategoryTheory.Stric... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | {
"line": 113,
"column": 4
} | {
"line": 113,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictPseudofunctorCore B C\na✝ b✝ : B\nf : a✝ ⟶ b✝\n⊢ S.map₂ (ρ_ f).hom = (eqToIso ⋯).hom ≫ S.map f ◁ (eqToIso ⋯).hom ≫ (ρ_ (S.map f)).hom",
"usedConstants": [
"CategoryTheory.Stric... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | {
"line": 168,
"column": 4
} | {
"line": 168,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝⁴ : Bicategory B\nC : Type u₂\ninst✝³ : Bicategory C\nD : Type u₃\ninst✝² : Bicategory D\ninst✝¹ : Strict B\ninst✝ : Strict C\nS : StrictPseudofunctorPreCore B C\na✝ b✝ c✝ : B\nf : a✝ ⟶ b✝\nx✝¹ x✝ : b✝ ⟶ c✝\nη : x✝¹ ⟶ x✝\n⊢ S.map₂ (f ◁ η) = (eqToIso ⋯).hom ≫ S.map f ◁ S.map₂ η ≫ (eqTo... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | {
"line": 170,
"column": 4
} | {
"line": 170,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝⁴ : Bicategory B\nC : Type u₂\ninst✝³ : Bicategory C\nD : Type u₃\ninst✝² : Bicategory D\ninst✝¹ : Strict B\ninst✝ : Strict C\nS : StrictPseudofunctorPreCore B C\na✝ b✝ c✝ : B\nf✝ g✝ : a✝ ⟶ b✝\nη : f✝ ⟶ g✝\nf : b✝ ⟶ c✝\n⊢ S.map₂ (η ▷ f) = (eqToIso ⋯).hom ≫ S.map₂ η ▷ S.map f ≫ (eqToIs... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {
"line": 134,
"column": 4
} | {
"line": 134,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictlyUnitaryLaxFunctorCore B C\na✝ b✝ c✝ d✝ : B\nf : a✝ ⟶ b✝\ng : b✝ ⟶ c✝\nh : c✝ ⟶ d✝\n⊢ S.mapComp f g ▷ S.map h ≫ S.mapComp (f ≫ g) h ≫ S.map₂ (α_ f g h).hom =\n (α_ (S.map f) (S.map g... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {
"line": 130,
"column": 4
} | {
"line": 130,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictlyUnitaryLaxFunctorCore B C\na✝ b✝ : B\nf : a✝ ⟶ b✝\n⊢ S.map₂ (λ_ f).inv = (λ_ (S.map f)).inv ≫ eqToHom ⋯ ▷ S.map f ≫ S.mapComp (𝟙 a✝) f",
"usedConstants": [
"Eq.mpr",
"... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {
"line": 132,
"column": 4
} | {
"line": 132,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictlyUnitaryLaxFunctorCore B C\na✝ b✝ : B\nf : a✝ ⟶ b✝\n⊢ S.map₂ (ρ_ f).inv = (ρ_ (S.map f)).inv ≫ S.map f ◁ eqToHom ⋯ ≫ S.mapComp f (𝟙 b✝)",
"usedConstants": [
"Eq.mpr",
"... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {
"line": 298,
"column": 4
} | {
"line": 298,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictlyUnitaryPseudofunctorCore B C\na✝ b✝ c✝ : B\nf : a✝ ⟶ b✝\nx✝¹ x✝ : b✝ ⟶ c✝\nη : x✝¹ ⟶ x✝\n⊢ S.map₂ (f ◁ η) = (S.mapComp f x✝¹).hom ≫ S.map f ◁ S.map₂ η ≫ (S.mapComp f x✝).inv",
"use... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {
"line": 300,
"column": 4
} | {
"line": 300,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictlyUnitaryPseudofunctorCore B C\na✝ b✝ c✝ : B\nf✝ g✝ : a✝ ⟶ b✝\nη : f✝ ⟶ g✝\nf : b✝ ⟶ c✝\n⊢ S.map₂ (η ▷ f) = (S.mapComp f✝ f).hom ≫ S.map₂ η ▷ S.map f ≫ (S.mapComp g✝ f).inv",
"usedCo... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {
"line": 296,
"column": 4
} | {
"line": 296,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictlyUnitaryPseudofunctorCore B C\na✝ b✝ c✝ d✝ : B\nf : a✝ ⟶ b✝\ng : b✝ ⟶ c✝\nh : c✝ ⟶ d✝\n⊢ S.map₂ (α_ f g h).hom =\n (S.mapComp (f ≫ g) h).hom ≫\n (S.mapComp f g).hom ▷ S.map h ≫\... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {
"line": 292,
"column": 4
} | {
"line": 292,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictlyUnitaryPseudofunctorCore B C\na✝ b✝ : B\nf : a✝ ⟶ b✝\n⊢ S.map₂ (λ_ f).hom = (S.mapComp (𝟙 a✝) f).hom ≫ (eqToIso ⋯).hom ▷ S.map f ≫ (λ_ (S.map f)).hom",
"usedConstants": [
"E... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {
"line": 294,
"column": 4
} | {
"line": 294,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nS : StrictlyUnitaryPseudofunctorCore B C\na✝ b✝ : B\nf : a✝ ⟶ b✝\n⊢ S.map₂ (ρ_ f).hom = (S.mapComp f (𝟙 b✝)).hom ≫ S.map f ◁ (eqToIso ⋯).hom ≫ (ρ_ (S.map f)).hom",
"usedConstants": [
"E... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Modification.Lax | {
"line": 132,
"column": 4
} | {
"line": 132,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝¹ : Bicategory B\nC : Type u₂\ninst✝ : Bicategory C\nF G : B ⥤ᴸ C\nη θ : F ⟶ G\napp : (a : B) → η.app a ≅ θ.app a\nnaturality : ∀ {a b : B} (f : a ⟶ b), (app a).hom ▷ G.map f ≫ θ.naturality f = η.naturality f ≫ F.map f ◁ (app b).hom\na b : B\nf : a ⟶ b\n⊢ (app a).inv ▷ G.map f ≫ η.nat... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Modification.Lax | {
"line": 219,
"column": 4
} | {
"line": 219,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝¹ : Bicategory B\nC : Type u₂\ninst✝ : Bicategory C\nF G : B ⥤ᴸ C\nη θ : F ⟶ G\napp : (a : B) → η.app a ≅ θ.app a\nnaturality : ∀ {a b : B} (f : a ⟶ b), F.map f ◁ (app b).hom ≫ θ.naturality f = η.naturality f ≫ (app a).hom ▷ G.map f\na b : B\nf : a ⟶ b\n⊢ F.map f ◁ (app b).inv ≫ η.nat... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {
"line": 159,
"column": 4
} | {
"line": 159,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝¹ : Bicategory B\nC : Type u₂\ninst✝ : Bicategory C\nF G : B ⥤ᵒᵖᴸ C\nη θ : F ⟶ G\napp : (a : B) → η.app a ≅ θ.app a\nnaturality : ∀ {a b : B} (f : a ⟶ b), (app a).hom ▷ G.map f ≫ θ.naturality f = η.naturality f ≫ F.map f ◁ (app b).hom\na b : B\nf : a ⟶ b\n⊢ (app a).inv ▷ G.map f ≫ η.n... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {
"line": 260,
"column": 4
} | {
"line": 260,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝¹ : Bicategory B\nC : Type u₂\ninst✝ : Bicategory C\nF G : B ⥤ᵒᵖᴸ C\nη θ : F ⟶ G\napp : (a : B) → η.app a ≅ θ.app a\nnaturality : ∀ {a b : B} (f : a ⟶ b), F.map f ◁ (app b).hom ≫ θ.naturality f = η.naturality f ≫ (app a).hom ▷ G.map f\na b : B\nf : a ⟶ b\n⊢ F.map f ◁ (app b).inv ≫ η.n... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {
"line": 304,
"column": 21
} | {
"line": 304,
"column": 32
} | [
{
"pp": "B : Type u₁\ninst✝¹ : Bicategory B\nC : Type u₂\ninst✝ : Bicategory C\nF G : B ⥤ᵒᵖᴸ C\nη θ : F ⟶ G\nΓ✝ : Modification η θ\nΓ : (StrongTrans.toOplax η).Modification (StrongTrans.toOplax θ)\na✝ b✝ : B\nf : a✝ ⟶ b✝\n⊢ F.map f ◁ Γ.app b✝ ≫ (θ.naturality f).hom = (η.naturality f).hom ≫ Γ.app a✝ ▷ G.map f",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {
"line": 386,
"column": 4
} | {
"line": 386,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝¹ : Bicategory B\nC : Type u₂\ninst✝ : Bicategory C\nF G : B ⥤ᵒᵖᴸ C\nη θ : F ⟶ G\napp : (a : B) → η.app a ≅ θ.app a\nnaturality :\n ∀ {a b : B} (f : a ⟶ b), F.map f ◁ (app b).hom ≫ (θ.naturality f).hom = (η.naturality f).hom ≫ (app a).hom ▷ G.map f\na b : B\nf : a ⟶ b\n⊢ F.map f ◁ (a... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Modification.Pseudo | {
"line": 164,
"column": 4
} | {
"line": 164,
"column": 15
} | [
{
"pp": "B : Type u₁\ninst✝¹ : Bicategory B\nC : Type u₂\ninst✝ : Bicategory C\nF G : B ⥤ᵖ C\nη θ : F ⟶ G\napp : (a : B) → η.app a ≅ θ.app a\nnaturality :\n ∀ {a b : B} (f : a ⟶ b), F.map f ◁ (app b).hom ≫ (θ.naturality f).hom = (η.naturality f).hom ≫ (app a).hom ▷ G.map f\na b : B\nf : a ⟶ b\n⊢ F.map f ◁ (app... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.InducedBicategory | {
"line": 115,
"column": 50
} | {
"line": 115,
"column": 61
} | [
{
"pp": "case h\nB : Type u_1\nC : Type u_2\ninst✝ : Bicategory C\nF : B → C\nx✝⁶ x✝⁵ x✝⁴ : InducedBicategory C F\nx✝³ x✝² : x✝⁶ ⟶ x✝⁵\nx✝¹ x✝ : x✝⁵ ⟶ x✝⁴\nη : x✝³ ⟶ x✝²\nθ : x✝¹ ⟶ x✝\n⊢ (mkHom₂ (x✝³.hom ◁ θ.hom) ≫ mkHom₂ (η.hom ▷ x✝.hom)).hom = (mkHom₂ (η.hom ▷ x✝¹.hom) ≫ mkHom₂ (x✝².hom ◁ θ.hom)).hom",
"u... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Grothendieck | {
"line": 124,
"column": 15
} | {
"line": 124,
"column": 30
} | [
{
"pp": "𝒮 : Type u₁\ninst✝ : Category.{v₁, u₁} 𝒮\nF : LocallyDiscrete 𝒮 ⥤ᵖ Cat\na b : ∫ F\nf g : a ⟶ b\nhfg : f = g\n⊢ ∃ (hfg : f.base = g.base), eqToHom ⋯ ≫ f.fiber = g.fiber",
"usedConstants": [
"CategoryTheory.LocallyDiscrete.mk",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Ho... | subst hfg; simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Grothendieck | {
"line": 124,
"column": 15
} | {
"line": 124,
"column": 30
} | [
{
"pp": "𝒮 : Type u₁\ninst✝ : Category.{v₁, u₁} 𝒮\nF : LocallyDiscrete 𝒮 ⥤ᵖ Cat\na b : ∫ F\nf g : a ⟶ b\nhfg : f = g\n⊢ ∃ (hfg : f.base = g.base), eqToHom ⋯ ≫ f.fiber = g.fiber",
"usedConstants": [
"CategoryTheory.LocallyDiscrete.mk",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Ho... | subst hfg; simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Grothendieck | {
"line": 307,
"column": 4
} | {
"line": 309,
"column": 98
} | [
{
"pp": "𝒮 : Type u₁\ninst✝ : Category.{v₁, u₁} 𝒮\nF : LocallyDiscrete 𝒮ᵒᵖ ⥤ᵖ Cat\nW✝ X✝ Y✝ Z✝ : ∫ᶜ F\nf : W✝ ⟶ X✝\ng : X✝ ⟶ Y✝\nh : Y✝ ⟶ Z✝\n⊢ (f ≫ g) ≫ h = f ≫ g ≫ h",
"usedConstants": [
"_private.Mathlib.CategoryTheory.Bicategory.Grothendieck.0.CategoryTheory.Pseudofunctor.CoGrothendieck.categor... | ext
· simp
· simp [← NatTrans.naturality_assoc, F.mapComp_assoc_right_inv_app, Strict.associator_eqToIso] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Bicategory.Grothendieck | {
"line": 307,
"column": 4
} | {
"line": 309,
"column": 98
} | [
{
"pp": "𝒮 : Type u₁\ninst✝ : Category.{v₁, u₁} 𝒮\nF : LocallyDiscrete 𝒮ᵒᵖ ⥤ᵖ Cat\nW✝ X✝ Y✝ Z✝ : ∫ᶜ F\nf : W✝ ⟶ X✝\ng : X✝ ⟶ Y✝\nh : Y✝ ⟶ Z✝\n⊢ (f ≫ g) ≫ h = f ≫ g ≫ h",
"usedConstants": [
"_private.Mathlib.CategoryTheory.Bicategory.Grothendieck.0.CategoryTheory.Pseudofunctor.CoGrothendieck.categor... | ext
· simp
· simp [← NatTrans.naturality_assoc, F.mapComp_assoc_right_inv_app, Strict.associator_eqToIso] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | {
"line": 66,
"column": 6
} | {
"line": 66,
"column": 37
} | [
{
"pp": "B : Type u\ninst✝ : Bicategory B\na b c : B\nf : a ⟶ b\nu : b ⟶ a\nadj : f ⊣ u\nx : B\nh : a ⟶ x\ns : LeftExtension f (𝟙 a ≫ h)\nτ₀ : (LeftExtension.mk u adj.unit).whisker h ⟶ s\nτ : u ≫ h ⟶ s.extension := StructuredArrow.Hom.right τ₀\n⊢ adj.unit ▷ h ⊗≫ f ◁ τ = s.unit",
"usedConstants": [
"E... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | {
"line": 85,
"column": 4
} | {
"line": 85,
"column": 47
} | [
{
"pp": "B : Type u\ninst✝ : Bicategory B\na b c : B\nf : a ⟶ b\nt : LeftExtension f (𝟙 a)\nH : t.IsKan\nH' : (t.whisker f).IsKan\nε : t.extension ≫ f ⟶ 𝟙 b := H'.desc (LeftExtension.mk (𝟙 b) ((λ_ f).hom ≫ (ρ_ f).inv))\n⊢ leftZigzag t.unit ε = (λ_ f).hom ≫ (ρ_ f).inv",
"usedConstants": [
"Eq.mpr",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | {
"line": 146,
"column": 53
} | {
"line": 146,
"column": 84
} | [
{
"pp": "B : Type u\ninst✝ : Bicategory B\na b c : B\nf : a ⟶ b\nu : b ⟶ a\nadj : f ⊣ u\nx : B\nh : x ⟶ a\ns : LeftLift u (h ≫ 𝟙 a)\nτ₀ : (LeftLift.mk f adj.unit).whisker h ⟶ s\nτ : h ≫ f ⟶ s.lift := StructuredArrow.Hom.right τ₀\n⊢ h ◁ adj.unit ⊗≫ τ ▷ u = s.unit",
"usedConstants": [
"Eq.mpr",
"... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | {
"line": 165,
"column": 4
} | {
"line": 165,
"column": 48
} | [
{
"pp": "B : Type u\ninst✝ : Bicategory B\na b c : B\nu : b ⟶ a\nt : LeftLift u (𝟙 a)\nH : t.IsKan\nH' : (t.whisker u).IsKan\nε : u ≫ t.lift ⟶ 𝟙 b := H'.desc (LeftLift.mk (𝟙 b) ((ρ_ u).hom ≫ (λ_ u).inv))\n⊢ rightZigzag t.unit ε = (ρ_ u).hom ≫ (λ_ u).inv",
"usedConstants": [
"Eq.mpr",
"Categor... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | {
"line": 222,
"column": 8
} | {
"line": 222,
"column": 39
} | [
{
"pp": "B : Type u\ninst✝ : Bicategory B\na b c : B\nf : a ⟶ b\ng : a ⟶ c\nt : LeftExtension f g\nH : t.IsKan\nx : B\nh : c ⟶ x\nu : x ⟶ c\nadj : h ⊣ u\nη' : 𝟙 c ⟶ h ≫ u := adj.unit\nH' : (LeftLift.mk h η').IsAbsKan := fun {x_1} ↦ adj.isAbsoluteLeftKanLift\ns : LeftExtension f (g ≫ h)\nk : b ⟶ x := s.extensio... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Sigma.Basic | {
"line": 130,
"column": 4
} | {
"line": 130,
"column": 24
} | [
{
"pp": "I : Type w₁\nC : I → Type u₁\ninst✝¹ : (i : I) → Category.{v₁, u₁} (C i)\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nF : (i : I) → C i ⥤ D\ni : I\nX Y✝¹ : C i\nf : X ⟶ Y✝¹\nY✝ : C i\ng : Y✝¹ ⟶ Y✝\n⊢ descMap F ⟨i, X⟩ ⟨i, Y✝⟩ (SigmaHom.mk f ≫ SigmaHom.mk g) =\n descMap F ⟨i, X⟩ ⟨i, Y✝¹⟩ (SigmaHom.mk f)... | apply (F i).map_comp | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | {
"line": 225,
"column": 6
} | {
"line": 237,
"column": 20
} | [
{
"pp": "B : Type u\ninst✝ : Bicategory B\na b c : B\nf : a ⟶ b\ng : a ⟶ c\nt : LeftExtension f g\nH : t.IsKan\nx : B\nh : c ⟶ x\nu : x ⟶ c\nadj : h ⊣ u\nη' : 𝟙 c ⟶ h ≫ u := adj.unit\nH' : (LeftLift.mk h η').IsAbsKan := fun {x_1} ↦ adj.isAbsoluteLeftKanLift\ns : LeftExtension f (g ≫ h)\nk : b ⟶ x := s.extensio... | calc _
_ = (g ◁ η' ≫ t.unit ▷ (h ≫ u)) ⊗≫ f ◁ σ ▷ u ⊗≫ 𝟙 _ := by
bicategory
_ = t.unit ▷ (𝟙 c) ⊗≫ f ◁ (t.extension ◁ η' ⊗≫ σ ▷ u) ⊗≫ 𝟙 _ := by
rw [whisker_exchange]; bicategory
_ = (ρ_ g).hom ≫ t.unit ≫ f ◁ H.desc sτ ≫ (α_ f s.extension u).inv := by
rw [Hσ]
... | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcTactic |
Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | {
"line": 240,
"column": 52
} | {
"line": 240,
"column": 83
} | [
{
"pp": "B : Type u\ninst✝ : Bicategory B\na b c : B\nf : a ⟶ b\ng : a ⟶ c\nt : LeftExtension f g\nH : t.IsKan\nx : B\nh : c ⟶ x\nu : x ⟶ c\nadj : h ⊣ u\nη' : 𝟙 c ⟶ h ≫ u := adj.unit\nH' : (LeftLift.mk h η').IsAbsKan := fun {x_1} ↦ adj.isAbsoluteLeftKanLift\ns' : LeftExtension f (g ≫ h)\nτ₀' : t.whisker h ⟶ s'... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.CategoryTheory.Category.Cat.Adjunction | {
"line": 67,
"column": 24
} | {
"line": 67,
"column": 35
} | [
{
"pp": "case h.toFun.h\nX : Type u\nC : Cat\nx✝ : Cat\nx : ConnectedComponents ↑x✝\n⊢ (ConcreteCategory.hom (↾(𝟙 x✝).toFunctor.mapConnectedComponents)).toFun x =\n (ConcreteCategory.hom (𝟙 (ConnectedComponents ↑x✝))).toFun x",
"usedConstants": [
"CategoryTheory.Cat.category",
"Eq.mpr",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.