module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 365
values | kind stringclasses 368
values |
|---|---|---|---|---|---|---|
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 505,
"column": 48
} | {
"line": 505,
"column": 65
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nP : Prop\ninst✝ : Decidable P\nW X Y Z : C\nf : W ⟶ X\ng : P → (Y ⟶ Z)\ng' : ¬P → (Y ⟶ Z)\n⊢ (f ⊗ₘ if h : P then g h else g' h) = if h : P then f ⊗ₘ g h else f ⊗ₘ g' h",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Cat... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 509,
"column": 48
} | {
"line": 509,
"column": 65
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nP : Prop\ninst✝ : Decidable P\nW X Y Z : C\nf : W ⟶ X\ng : P → (Y ⟶ Z)\ng' : ¬P → (Y ⟶ Z)\n⊢ (if h : P then g h else g' h) ⊗ₘ f = if h : P then g h ⊗ₘ f else g' h ⊗ₘ f",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Cat... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 509,
"column": 48
} | {
"line": 509,
"column": 65
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nP : Prop\ninst✝ : Decidable P\nW X Y Z : C\nf : W ⟶ X\ng : P → (Y ⟶ Z)\ng' : ¬P → (Y ⟶ Z)\n⊢ (if h : P then g h else g' h) ⊗ₘ f = if h : P then g h ⊗ₘ f else g' h ⊗ₘ f",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Cat... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 509,
"column": 48
} | {
"line": 509,
"column": 65
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nP : Prop\ninst✝ : Decidable P\nW X Y Z : C\nf : W ⟶ X\ng : P → (Y ⟶ Z)\ng' : ¬P → (Y ⟶ Z)\n⊢ (if h : P then g h else g' h) ⊗ₘ f = if h : P then g h ⊗ₘ f else g' h ⊗ₘ f",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Cat... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 124,
"column": 2
} | {
"line": 125,
"column": 22
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\ninst✝³ : MonoidalCategory C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\ninst✝¹ : MonoidalCategory D\nF : C ⥤ D\ninst✝ : F.LaxMonoidal\nX Y Z : C\n⊢ F.obj X ◁ μ F Y Z ≫ μ F X (Y ⊗ Z) ≫ F.map (α_ X Y Z).inv =\n (α_ (F.obj X) (F.obj Y) (F.obj Z)).inv ≫ μ F X Y... | rw [Iso.eq_inv_comp, ← associativity_assoc, ← F.map_comp, Iso.hom_inv_id,
F.map_id, comp_id] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 124,
"column": 2
} | {
"line": 125,
"column": 22
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\ninst✝³ : MonoidalCategory C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\ninst✝¹ : MonoidalCategory D\nF : C ⥤ D\ninst✝ : F.LaxMonoidal\nX Y Z : C\n⊢ F.obj X ◁ μ F Y Z ≫ μ F X (Y ⊗ Z) ≫ F.map (α_ X Y Z).inv =\n (α_ (F.obj X) (F.obj Y) (F.obj Z)).inv ≫ μ F X Y... | rw [Iso.eq_inv_comp, ← associativity_assoc, ← F.map_comp, Iso.hom_inv_id,
F.map_id, comp_id] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 124,
"column": 2
} | {
"line": 125,
"column": 22
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\ninst✝³ : MonoidalCategory C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\ninst✝¹ : MonoidalCategory D\nF : C ⥤ D\ninst✝ : F.LaxMonoidal\nX Y Z : C\n⊢ F.obj X ◁ μ F Y Z ≫ μ F X (Y ⊗ Z) ≫ F.map (α_ X Y Z).inv =\n (α_ (F.obj X) (F.obj Y) (F.obj Z)).inv ≫ μ F X Y... | rw [Iso.eq_inv_comp, ← associativity_assoc, ← F.map_comp, Iso.hom_inv_id,
F.map_id, comp_id] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 487,
"column": 59
} | {
"line": 487,
"column": 74
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\ninst✝³ : MonoidalCategory C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\ninst✝¹ : MonoidalCategory D\nF : C ⥤ D\ninst✝ : F.Monoidal\nX Y Z : C\n⊢ (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom ≫ (α_ (F.obj X) (F.obj Y) (F.obj Z)).inv =\n (α_ (F.obj X) (F.obj Y) (F.o... | map_associator' | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 552,
"column": 4
} | {
"line": 552,
"column": 24
} | [
{
"pp": "case μ\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\ninst✝² : MonoidalCategory C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\ninst✝ : MonoidalCategory D\nF : C ⥤ D\na b : F.Monoidal\neq : a.toLaxMonoidal = b.toLaxMonoidal\n⊢ μ F = μ F",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver"... | exact congr(($eq).μ) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 552,
"column": 4
} | {
"line": 552,
"column": 24
} | [
{
"pp": "case μ\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\ninst✝² : MonoidalCategory C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\ninst✝ : MonoidalCategory D\nF : C ⥤ D\na b : F.Monoidal\neq : a.toLaxMonoidal = b.toLaxMonoidal\n⊢ μ F = μ F",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver"... | exact congr(($eq).μ) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 552,
"column": 4
} | {
"line": 552,
"column": 24
} | [
{
"pp": "case μ\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\ninst✝² : MonoidalCategory C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\ninst✝ : MonoidalCategory D\nF : C ⥤ D\na b : F.Monoidal\neq : a.toLaxMonoidal = b.toLaxMonoidal\n⊢ μ F = μ F",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver"... | exact congr(($eq).μ) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Tactic.CategoryTheory.Monoidal.PureCoherence | {
"line": 224,
"column": 6
} | {
"line": 224,
"column": 49
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : MonoidalCategory C\nf g f' : C\nη θ : f ≅ g\nη_f : 𝟙_ C ⊗ f ≅ f'\nη_g : 𝟙_ C ⊗ g ≅ f'\nh_η : 𝟙_ C ◁ η ≪≫ η_g = η_f\nh_θ : 𝟙_ C ◁ θ ≪≫ η_g = η_f\n⊢ (λ_ f).inv ≫ η_f.hom ≫ η_g.inv ≫ (λ_ g).hom = θ.hom",
"usedConstants": [
"CategoryTheory.Categ... | simp [← reassoc_of% (congrArg Iso.hom h_θ)] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Tactic.CategoryTheory.Monoidal.PureCoherence | {
"line": 224,
"column": 6
} | {
"line": 224,
"column": 49
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : MonoidalCategory C\nf g f' : C\nη θ : f ≅ g\nη_f : 𝟙_ C ⊗ f ≅ f'\nη_g : 𝟙_ C ⊗ g ≅ f'\nh_η : 𝟙_ C ◁ η ≪≫ η_g = η_f\nh_θ : 𝟙_ C ◁ θ ≪≫ η_g = η_f\n⊢ (λ_ f).inv ≫ η_f.hom ≫ η_g.inv ≫ (λ_ g).hom = θ.hom",
"usedConstants": [
"CategoryTheory.Categ... | simp [← reassoc_of% (congrArg Iso.hom h_θ)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.CategoryTheory.Monoidal.PureCoherence | {
"line": 224,
"column": 6
} | {
"line": 224,
"column": 49
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : MonoidalCategory C\nf g f' : C\nη θ : f ≅ g\nη_f : 𝟙_ C ⊗ f ≅ f'\nη_g : 𝟙_ C ⊗ g ≅ f'\nh_η : 𝟙_ C ◁ η ≪≫ η_g = η_f\nh_θ : 𝟙_ C ◁ θ ≪≫ η_g = η_f\n⊢ (λ_ f).inv ≫ η_f.hom ≫ η_g.inv ≫ (λ_ g).hom = θ.hom",
"usedConstants": [
"CategoryTheory.Categ... | simp [← reassoc_of% (congrArg Iso.hom h_θ)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | {
"line": 124,
"column": 2
} | {
"line": 124,
"column": 34
} | [
{
"pp": "case hf\nR : Type u\ninst✝ : CommSemiring R\nW : SemimoduleCat R\nX : SemimoduleCat R\nY : SemimoduleCat R\nZ : SemimoduleCat R\n⊢ Hom.hom\n (whiskerRight (associator W X Y).hom Z ≫\n (associator W (tensorObj X Y) Z).hom ≫ whiskerLeft W (associator X Y Z).hom) =\n Hom.hom ((associator (t... | apply TensorProduct.ext_fourfold | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 1306,
"column": 4
} | {
"line": 1306,
"column": 40
} | [
{
"pp": "case e_a\nC : Type u₁\ninst✝⁷ : Category.{v₁, u₁} C\ninst✝⁶ : MonoidalCategory C\nD : Type u₂\ninst✝⁵ : Category.{v₂, u₂} D\ninst✝⁴ : MonoidalCategory D\nE : Type u₃\ninst✝³ : Category.{v₃, u₃} E\ninst✝² : MonoidalCategory E\nC' : Type u₁'\ninst✝¹ : Category.{v₁', u₁'} C'\nF G : C ⥤ D\ninst✝ : F.Monoid... | simp [← id_tensorHom, -tensorHom_id] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Ring.BooleanRing | {
"line": 92,
"column": 61
} | {
"line": 92,
"column": 69
} | [
{
"pp": "α : Type u_1\ninst✝ : BooleanRing α\na b : α\n⊢ a * (a + b) + b * (a + b) = a * a + a * b + (b * a + b * b)",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"HMul.hMul",
"Ring.toNonAssocRing",
"congrArg",
"id",
"Distrib.toAdd",
"NonUnitalNon... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.BooleanRing | {
"line": 101,
"column": 53
} | {
"line": 101,
"column": 61
} | [
{
"pp": "α : Type u_1\ninst✝ : BooleanRing α\na : α\n⊢ a * (1 + a) = 0",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"HMul.hMul",
"Ring.toNonAssocRing",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
"NonUnitalNonAssocSemiring.toMulZeroClass",
... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.BooleanRing | {
"line": 195,
"column": 6
} | {
"line": 195,
"column": 14
} | [
{
"pp": "α : Type u_1\ninst✝ : BooleanRing α\na b : α\n⊢ a * (a + b + a * b) = a",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"congrArg",
"BooleanRing.toCommR... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.BooleanRing | {
"line": 195,
"column": 15
} | {
"line": 195,
"column": 23
} | [
{
"pp": "α : Type u_1\ninst✝ : BooleanRing α\na b : α\n⊢ a * (a + b) + a * (a * b) = a",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"congrArg",
"BooleanRing.t... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Coalgebra.TensorProduct | {
"line": 137,
"column": 21
} | {
"line": 137,
"column": 32
} | [
{
"pp": "case h.e'_2.tmul.tmul.a\nR : Type u_1\nS : Type u_2\nA : Type u_3\nB : Type u_4\ninst✝¹⁰ : CommSemiring R\ninst✝⁹ : CommSemiring S\ninst✝⁸ : AddCommMonoid A\ninst✝⁷ : AddCommMonoid B\ninst✝⁶ : Algebra R S\ninst✝⁵ : Module R A\ninst✝⁴ : Module S A\ninst✝³ : Module R B\ninst✝² : IsScalarTower R S A\ninst... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Coalgebra.TensorProduct | {
"line": 150,
"column": 21
} | {
"line": 150,
"column": 32
} | [
{
"pp": "case h.e'_2.tmul.tmul.a\nR : Type u_1\nS : Type u_2\nA : Type u_3\nB : Type u_4\ninst✝¹⁰ : CommSemiring R\ninst✝⁹ : CommSemiring S\ninst✝⁸ : AddCommMonoid A\ninst✝⁷ : AddCommMonoid B\ninst✝⁶ : Algebra R S\ninst✝⁵ : Module R A\ninst✝⁴ : Module S A\ninst✝³ : Module R B\ninst✝² : IsScalarTower R S A\ninst... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Category.Pointed | {
"line": 74,
"column": 22
} | {
"line": 74,
"column": 75
} | [
{
"pp": "X Y Z : Pointed\nf : X.Hom Y\ng : Y.Hom Z\n⊢ (g.toFun ∘ f.toFun) X.point = Z.point",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Function.comp",
"id",
"Pointed.Hom.map_point",
"Pointed.point",
"Eq.refl",
"Function.comp_apply",
"Pointed.X",
"... | by rw [Function.comp_apply, f.map_point, g.map_point] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Adjunction.Mates | {
"line": 210,
"column": 2
} | {
"line": 222,
"column": 57
} | [
{
"pp": "A : Type u₁\nB : Type u₂\nC : Type u₃\nD : Type u₄\nE : Type u₅\nF : Type u₆\ninst✝⁵ : Category.{v₁, u₁} A\ninst✝⁴ : Category.{v₂, u₂} B\ninst✝³ : Category.{v₃, u₃} C\ninst✝² : Category.{v₄, u₄} D\ninst✝¹ : Category.{v₅, u₅} E\ninst✝ : Category.{v₆, u₆} F\nG : A ⥤ D\nH : B ⥤ E\nK : C ⥤ F\nL₁ : A ⥤ B\nR... | unfold vComp hComp mateEquiv Adjunction.comp
ext c
simp only [comp_obj, whiskerRight_comp, assoc, mk'_unit, whiskerLeft_comp, mk'_counit,
whiskerRight_twice, Iso.inv_hom_id_assoc, Equiv.coe_fn_mk, comp_app, id_obj,
rightUnitor_inv_app, Functor.whiskerLeft_app, Functor.whiskerRight_app, map_id,
associato... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Adjunction.Mates | {
"line": 210,
"column": 2
} | {
"line": 222,
"column": 57
} | [
{
"pp": "A : Type u₁\nB : Type u₂\nC : Type u₃\nD : Type u₄\nE : Type u₅\nF : Type u₆\ninst✝⁵ : Category.{v₁, u₁} A\ninst✝⁴ : Category.{v₂, u₂} B\ninst✝³ : Category.{v₃, u₃} C\ninst✝² : Category.{v₄, u₄} D\ninst✝¹ : Category.{v₅, u₅} E\ninst✝ : Category.{v₆, u₆} F\nG : A ⥤ D\nH : B ⥤ E\nK : C ⥤ F\nL₁ : A ⥤ B\nR... | unfold vComp hComp mateEquiv Adjunction.comp
ext c
simp only [comp_obj, whiskerRight_comp, assoc, mk'_unit, whiskerLeft_comp, mk'_counit,
whiskerRight_twice, Iso.inv_hom_id_assoc, Equiv.coe_fn_mk, comp_app, id_obj,
rightUnitor_inv_app, Functor.whiskerLeft_app, Functor.whiskerRight_app, map_id,
associato... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Adjunction.Mates | {
"line": 322,
"column": 2
} | {
"line": 322,
"column": 31
} | [
{
"pp": "C : Type u₁\nD : Type u₂\ninst✝¹ : Category.{v₁, u₁} C\ninst✝ : Category.{v₂, u₂} D\nL₁ : C ⥤ D\nR₁ : D ⥤ C\nadj₁ : L₁ ⊣ R₁\n⊢ 𝟙 R₁ = (conjugateEquiv adj₁ adj₁) (𝟙 L₁)",
"usedConstants": [
"CategoryTheory.Functor",
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",... | simp only [conjugateEquiv_id] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Category.Ring.Colimits | {
"line": 192,
"column": 17
} | {
"line": 192,
"column": 57
} | [
{
"pp": "J : Type v\ninst✝ : SmallCategory J\nF : J ⥤ RingCat\nj : J\n⊢ coconeFun F j 0 = 0",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Quot.sound",
"AddMonoid.toAddZeroClass",
"RingCat.ring",
"AddZeroClass.toAddZero",
"RingCat.Colimits.colimitSetoid"... | by apply Quot.sound; apply Relation.zero | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Category.Ring.Colimits | {
"line": 490,
"column": 17
} | {
"line": 490,
"column": 57
} | [
{
"pp": "J : Type v\ninst✝ : SmallCategory J\nF : J ⥤ CommRingCat\nj : J\n⊢ coconeFun F j 0 = 0",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"CommRingCat.carrier",
"Quot.sound",
"CommSemiring.toSemiring",
"AddMonoid.toAddZeroClass",
"CommRingCat.Colimit... | by apply Quot.sound; apply Relation.zero | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Jacobson.Ideal | {
"line": 125,
"column": 6
} | {
"line": 125,
"column": 14
} | [
{
"pp": "case h\nR : Type u\ninst✝ : Ring R\nI : Ideal R\nr : R\nh : r ∈ I.jacobson\ns : R\nhs : s * 1 * r + s - 1 ∈ I\n⊢ s * (r + 1) - 1 ∈ I",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"Semiring.toModule",
"HMul.hMul",
"Ring.toNonAssocRing",
"AddGroupWithO... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Jacobson.Radical | {
"line": 159,
"column": 4
} | {
"line": 159,
"column": 22
} | [
{
"pp": "R : Type u_1\ninst✝¹ : Ring R\nI : Ideal R\ninst✝ : I.IsTwoSided\nf : R ⧸ I →ₛₗ[Ideal.Quotient.mk I] R ⧸ I := { toAddHom := AddHom.id (R ⧸ I), map_smul' := ⋯ }\n⊢ ↑(Submodule.map f (Module.jacobson R (R ⧸ I))) = ↑(Module.jacobson R (R ⧸ I))",
"usedConstants": [
"Submodule",
"Semiring.to... | apply Set.image_id | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.RingTheory.Jacobson.Radical | {
"line": 159,
"column": 4
} | {
"line": 159,
"column": 22
} | [
{
"pp": "R : Type u_1\ninst✝¹ : Ring R\nI : Ideal R\ninst✝ : I.IsTwoSided\nf : R ⧸ I →ₛₗ[Ideal.Quotient.mk I] R ⧸ I := { toAddHom := AddHom.id (R ⧸ I), map_smul' := ⋯ }\n⊢ ↑(Submodule.map f (Module.jacobson R (R ⧸ I))) = ↑(Module.jacobson R (R ⧸ I))",
"usedConstants": [
"Submodule",
"Semiring.to... | apply Set.image_id | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Jacobson.Radical | {
"line": 159,
"column": 4
} | {
"line": 159,
"column": 22
} | [
{
"pp": "R : Type u_1\ninst✝¹ : Ring R\nI : Ideal R\ninst✝ : I.IsTwoSided\nf : R ⧸ I →ₛₗ[Ideal.Quotient.mk I] R ⧸ I := { toAddHom := AddHom.id (R ⧸ I), map_smul' := ⋯ }\n⊢ ↑(Submodule.map f (Module.jacobson R (R ⧸ I))) = ↑(Module.jacobson R (R ⧸ I))",
"usedConstants": [
"Submodule",
"Semiring.to... | apply Set.image_id | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Localization.Away.Basic | {
"line": 125,
"column": 4
} | {
"line": 127,
"column": 35
} | [
{
"pp": "case refine_2\nR : Type u_1\ninst✝³ : CommSemiring R\nS : Type u_2\ninst✝² : CommSemiring S\ninst✝¹ : Algebra R S\nr : R\ninst✝ : Away r S\nu : Rˣ\ns : S\n⊢ ∃ n a, s * (algebraMap R S) (r * ↑u) ^ n = (algebraMap R S) a",
"usedConstants": [
"Units.val",
"RingHom.instRingHomClass",
... | obtain ⟨n, a, hn⟩ := surj r s
use n, a * u ^ n
simp [mul_pow, ← mul_assoc, hn] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Localization.Away.Basic | {
"line": 125,
"column": 4
} | {
"line": 127,
"column": 35
} | [
{
"pp": "case refine_2\nR : Type u_1\ninst✝³ : CommSemiring R\nS : Type u_2\ninst✝² : CommSemiring S\ninst✝¹ : Algebra R S\nr : R\ninst✝ : Away r S\nu : Rˣ\ns : S\n⊢ ∃ n a, s * (algebraMap R S) (r * ↑u) ^ n = (algebraMap R S) a",
"usedConstants": [
"Units.val",
"RingHom.instRingHomClass",
... | obtain ⟨n, a, hn⟩ := surj r s
use n, a * u ^ n
simp [mul_pow, ← mul_assoc, hn] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Localization.Away.Basic | {
"line": 453,
"column": 2
} | {
"line": 455,
"column": 86
} | [
{
"pp": "case refine_2\nS : Type u_4\nT : Type u_5\ninst✝⁶ : CommRing S\ninst✝⁵ : CommRing T\ninst✝⁴ : Algebra S T\nR : Type u_6\ninst✝³ : CommRing R\ninst✝² : Algebra R S\ninst✝¹ : Algebra R T\ninst✝ : IsScalarTower R S T\nh₁ : Function.Surjective ⇑(algebraMap S T)\nh₂ : Function.Surjective ⇑(algebraMap R S)\n... | · rw [← (RingHom.ker (algebraMap S T)).map_comap_of_surjective _ h₂, ← map_pow,
← Ideal.map_pointwise_smul, RingHom.comap_ker, ← IsScalarTower.algebraMap_eq]
rwa [RingHom.ker_eq_comap_bot (algebraMap R S), ← Ideal.map_le_iff_le_comap] at hn | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.CategoryTheory.Limits.Shapes.StrictInitial | {
"line": 253,
"column": 63
} | {
"line": 253,
"column": 91
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nI : C\nh : ∀ (A : C) (f : I ⟶ A), IsIso f\nI' A : C\nf : I' ⟶ A\nhI' : IsTerminal I'\nthis : IsIso (hI'.from I ≫ f)\n⊢ (inv (hI'.from I ≫ f) ≫ hI'.from I) ≫ f = 𝟙 A",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryThe... | rw [assoc, IsIso.inv_hom_id] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Limits.Shapes.StrictInitial | {
"line": 253,
"column": 63
} | {
"line": 253,
"column": 91
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nI : C\nh : ∀ (A : C) (f : I ⟶ A), IsIso f\nI' A : C\nf : I' ⟶ A\nhI' : IsTerminal I'\nthis : IsIso (hI'.from I ≫ f)\n⊢ (inv (hI'.from I ≫ f) ≫ hI'.from I) ≫ f = 𝟙 A",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryThe... | rw [assoc, IsIso.inv_hom_id] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.StrictInitial | {
"line": 253,
"column": 63
} | {
"line": 253,
"column": 91
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nI : C\nh : ∀ (A : C) (f : I ⟶ A), IsIso f\nI' A : C\nf : I' ⟶ A\nhI' : IsTerminal I'\nthis : IsIso (hI'.from I ≫ f)\n⊢ (inv (hI'.from I ≫ f) ≫ hI'.from I) ≫ f = 𝟙 A",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryThe... | rw [assoc, IsIso.inv_hom_id] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Localization.Integer | {
"line": 83,
"column": 2
} | {
"line": 84,
"column": 32
} | [
{
"pp": "R : Type u_1\ninst✝³ : CommSemiring R\nM : Submonoid R\nS : Type u_2\ninst✝² : CommSemiring S\ninst✝¹ : Algebra R S\ninst✝ : IsLocalization M S\na : S\n⊢ ∃ b, IsInteger R (↑b • a)",
"usedConstants": [
"IsLocalization.IsInteger",
"Eq.mpr",
"instHSMul",
"HMul.hMul",
"Com... | simp_rw [Algebra.smul_def, mul_comm _ a]
apply exists_integer_multiple' | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Localization.Integer | {
"line": 83,
"column": 2
} | {
"line": 84,
"column": 32
} | [
{
"pp": "R : Type u_1\ninst✝³ : CommSemiring R\nM : Submonoid R\nS : Type u_2\ninst✝² : CommSemiring S\ninst✝¹ : Algebra R S\ninst✝ : IsLocalization M S\na : S\n⊢ ∃ b, IsInteger R (↑b • a)",
"usedConstants": [
"IsLocalization.IsInteger",
"Eq.mpr",
"instHSMul",
"HMul.hMul",
"Com... | simp_rw [Algebra.smul_def, mul_comm _ a]
apply exists_integer_multiple' | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | {
"line": 152,
"column": 2
} | {
"line": 152,
"column": 47
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝³ : Category.{v₂, u₂} D\nG : C ⥤ D\nX Y Z : C\nf : X ⟶ Z\ng : Y ⟶ Z\ninst✝² : PreservesLimit (cospan f g) G\ninst✝¹ : HasPullback f g\ninst✝ : HasPullback (G.map f) (G.map g)\n⊢ (iso G f g).inv ≫ G.map (pullback.fst f g) = pullback.fst (G.map... | simp [PreservesPullback.iso, Iso.inv_comp_eq] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | {
"line": 152,
"column": 2
} | {
"line": 152,
"column": 47
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝³ : Category.{v₂, u₂} D\nG : C ⥤ D\nX Y Z : C\nf : X ⟶ Z\ng : Y ⟶ Z\ninst✝² : PreservesLimit (cospan f g) G\ninst✝¹ : HasPullback f g\ninst✝ : HasPullback (G.map f) (G.map g)\n⊢ (iso G f g).inv ≫ G.map (pullback.fst f g) = pullback.fst (G.map... | simp [PreservesPullback.iso, Iso.inv_comp_eq] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | {
"line": 152,
"column": 2
} | {
"line": 152,
"column": 47
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝³ : Category.{v₂, u₂} D\nG : C ⥤ D\nX Y Z : C\nf : X ⟶ Z\ng : Y ⟶ Z\ninst✝² : PreservesLimit (cospan f g) G\ninst✝¹ : HasPullback f g\ninst✝ : HasPullback (G.map f) (G.map g)\n⊢ (iso G f g).inv ≫ G.map (pullback.fst f g) = pullback.fst (G.map... | simp [PreservesPullback.iso, Iso.inv_comp_eq] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | {
"line": 158,
"column": 2
} | {
"line": 158,
"column": 47
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝³ : Category.{v₂, u₂} D\nG : C ⥤ D\nX Y Z : C\nf : X ⟶ Z\ng : Y ⟶ Z\ninst✝² : PreservesLimit (cospan f g) G\ninst✝¹ : HasPullback f g\ninst✝ : HasPullback (G.map f) (G.map g)\n⊢ (iso G f g).inv ≫ G.map (pullback.snd f g) = pullback.snd (G.map... | simp [PreservesPullback.iso, Iso.inv_comp_eq] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | {
"line": 158,
"column": 2
} | {
"line": 158,
"column": 47
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝³ : Category.{v₂, u₂} D\nG : C ⥤ D\nX Y Z : C\nf : X ⟶ Z\ng : Y ⟶ Z\ninst✝² : PreservesLimit (cospan f g) G\ninst✝¹ : HasPullback f g\ninst✝ : HasPullback (G.map f) (G.map g)\n⊢ (iso G f g).inv ≫ G.map (pullback.snd f g) = pullback.snd (G.map... | simp [PreservesPullback.iso, Iso.inv_comp_eq] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | {
"line": 158,
"column": 2
} | {
"line": 158,
"column": 47
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝³ : Category.{v₂, u₂} D\nG : C ⥤ D\nX Y Z : C\nf : X ⟶ Z\ng : Y ⟶ Z\ninst✝² : PreservesLimit (cospan f g) G\ninst✝¹ : HasPullback f g\ninst✝ : HasPullback (G.map f) (G.map g)\n⊢ (iso G f g).inv ≫ G.map (pullback.snd f g) = pullback.snd (G.map... | simp [PreservesPullback.iso, Iso.inv_comp_eq] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monad.Basic | {
"line": 336,
"column": 4
} | {
"line": 336,
"column": 20
} | [
{
"pp": "case e_a\nC : Type u₁\ninst✝ : Category.{v₁, u₁} C\nT✝ : Monad C\nG : Comonad C\nF : C ⥤ C\nT : Monad C\ni : T.toFunctor ≅ F\nX : C\n⊢ (T.map (T.map (i.inv.app X)) ≫ T.map (T.μ.app X)) ≫ T.μ.app X =\n ((T.toFunctor ⋙ T.toFunctor).map (i.inv.app X) ≫ T.μ.app (T.obj X)) ≫ T.μ.app X",
"usedConstant... | simp [T.assoc X] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Monad.Algebra | {
"line": 371,
"column": 19
} | {
"line": 371,
"column": 54
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nG : Comonad C\nX : G.Coalgebra\nY : C\nf : G.forget.obj X ⟶ Y\n⊢ X.a ≫ G.map (X.a ≫ G.map f) = (X.a ≫ G.map f) ≫ (G.cofree.obj Y).a",
"usedConstants": [
"CategoryTheory.Category.assoc",
"CategoryTheory.Comonad.Coalgebra.a",
"CategoryTheory... | by simp [← Coalgebra.coassoc_assoc] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Module.LocalizedModule.Basic | {
"line": 307,
"column": 45
} | {
"line": 307,
"column": 82
} | [
{
"pp": "case h\nR : Type u\ninst✝⁵ : CommSemiring R\nS : Submonoid R\nM : Type v\ninst✝⁴ : AddCommMonoid M\ninst✝³ : Module R M\nT : Type u_1\ninst✝² : CommSemiring T\ninst✝¹ : Algebra R T\ninst✝ : IsLocalization S T\nx y : T\nm : M\ns : ↥S\n⊢ (IsLocalization.mk' T (IsLocalization.sec S x).1 (IsLocalization.se... | ← IsLocalization.mk'_sec (M := S) T y | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Module.LocalizedModule.Basic | {
"line": 369,
"column": 19
} | {
"line": 369,
"column": 34
} | [
{
"pp": "R : Type u\ninst✝² : CommSemiring R\nS : Submonoid R\nM : Type v\ninst✝¹ : AddCommMonoid M\ninst✝ : Module R M\ns s' : ↥S\nm : M\n⊢ 1 • s • s' • m = 1 • (s * s') • m",
"usedConstants": [
"instHSMul",
"Submonoid.mul",
"HMul.hMul",
"MulMemClass.toSemigroup",
"CommSemirin... | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Module.LocalizedModule.Basic | {
"line": 369,
"column": 19
} | {
"line": 369,
"column": 34
} | [
{
"pp": "R : Type u\ninst✝² : CommSemiring R\nS : Submonoid R\nM : Type v\ninst✝¹ : AddCommMonoid M\ninst✝ : Module R M\ns s' : ↥S\nm : M\n⊢ 1 • s • s' • m = 1 • (s * s') • m",
"usedConstants": [
"instHSMul",
"Submonoid.mul",
"HMul.hMul",
"MulMemClass.toSemigroup",
"CommSemirin... | simp [mul_smul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Module.LocalizedModule.Basic | {
"line": 369,
"column": 19
} | {
"line": 369,
"column": 34
} | [
{
"pp": "R : Type u\ninst✝² : CommSemiring R\nS : Submonoid R\nM : Type v\ninst✝¹ : AddCommMonoid M\ninst✝ : Module R M\ns s' : ↥S\nm : M\n⊢ 1 • s • s' • m = 1 • (s * s') • m",
"usedConstants": [
"instHSMul",
"Submonoid.mul",
"HMul.hMul",
"MulMemClass.toSemigroup",
"CommSemirin... | simp [mul_smul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Module.LocalizedModule.Basic | {
"line": 863,
"column": 2
} | {
"line": 863,
"column": 37
} | [
{
"pp": "R : Type u_1\ninst✝⁷ : CommSemiring R\nS : Submonoid R\nM : Type u_2\nM' : Type u_3\nM'' : Type u_4\ninst✝⁶ : AddCommMonoid M\ninst✝⁵ : AddCommMonoid M'\ninst✝⁴ : AddCommMonoid M''\ninst✝³ : Module R M\ninst✝² : Module R M'\ninst✝¹ : Module R M''\nf : M →ₗ[R] M'\ninst✝ : IsLocalizedModule S f\ng : M →ₗ... | dsimp only [IsLocalizedModule.lift] | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.Algebra.Module.LocalizedModule.Basic | {
"line": 883,
"column": 2
} | {
"line": 883,
"column": 37
} | [
{
"pp": "R : Type u_1\ninst✝⁷ : CommSemiring R\nS : Submonoid R\nM : Type u_2\nM' : Type u_3\nM'' : Type u_4\ninst✝⁶ : AddCommMonoid M\ninst✝⁵ : AddCommMonoid M'\ninst✝⁴ : AddCommMonoid M''\ninst✝³ : Module R M\ninst✝² : Module R M'\ninst✝¹ : Module R M''\nf : M →ₗ[R] M'\ninst✝ : IsLocalizedModule S f\ng : M →ₗ... | dsimp only [IsLocalizedModule.lift] | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.Algebra.Category.Ring.Under.Basic | {
"line": 106,
"column": 16
} | {
"line": 108,
"column": 8
} | [
{
"pp": "R S : CommRingCat\nA B : Type u\ninst✝³ : CommRing A\ninst✝² : CommRing B\ninst✝¹ : Algebra (↑R) A\ninst✝ : Algebra (↑R) B\nf : A ≃ₐ[↑R] B\n⊢ (↑f.symm).toUnder ≫ (↑f).toUnder = 𝟙 (R.mkUnder B)",
"usedConstants": [
"CategoryTheory.instCategoryUnder",
"CategoryTheory.Comma.right",
... | by
ext a
simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Category.Ring.Constructions | {
"line": 356,
"column": 4
} | {
"line": 356,
"column": 66
} | [
{
"pp": "case property.right.hf.a\nA B : CommRingCat\nf g : A ⟶ B\ns : Fork f g\nm : s.pt ⟶ (equalizerFork f g).pt\nhm : m ≫ (equalizerFork f g).ι = s.ι\nx : ↑s.pt\n⊢ (Hom.hom m) x = (Hom.hom (ofHom ((Hom.hom s.ι).codRestrict ((Hom.hom f).eqLocus (Hom.hom g)) ⋯))) x",
"usedConstants": [
"CommRingCat.H... | exact Subtype.ext <| RingHom.congr_fun (congrArg Hom.hom hm) x | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.MorphismProperty.Comma | {
"line": 269,
"column": 2
} | {
"line": 270,
"column": 43
} | [
{
"pp": "A : Type u_1\ninst✝⁵ : Category.{v_1, u_1} A\nB : Type u_2\ninst✝⁴ : Category.{v_2, u_2} B\nT : Type u_3\ninst✝³ : Category.{v_3, u_3} T\nL : A ⥤ T\nR : B ⥤ T\nP : MorphismProperty T\nQ : MorphismProperty A\nW : MorphismProperty B\ninst✝² : Q.IsMultiplicative\ninst✝¹ : W.IsMultiplicative\nX Y : Morphis... | apply IsIso.eq_inv_of_hom_inv_id
rw [← comp_hom, IsIso.hom_inv_id, id_hom] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.MorphismProperty.Comma | {
"line": 269,
"column": 2
} | {
"line": 270,
"column": 43
} | [
{
"pp": "A : Type u_1\ninst✝⁵ : Category.{v_1, u_1} A\nB : Type u_2\ninst✝⁴ : Category.{v_2, u_2} B\nT : Type u_3\ninst✝³ : Category.{v_3, u_3} T\nL : A ⥤ T\nR : B ⥤ T\nP : MorphismProperty T\nQ : MorphismProperty A\nW : MorphismProperty B\ninst✝² : Q.IsMultiplicative\ninst✝¹ : W.IsMultiplicative\nX Y : Morphis... | apply IsIso.eq_inv_of_hom_inv_id
rw [← comp_hom, IsIso.hom_inv_id, id_hom] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.MorphismProperty.Comma | {
"line": 622,
"column": 2
} | {
"line": 624,
"column": 11
} | [
{
"pp": "T : Type u_1\ninst✝¹ : Category.{v_1, u_1} T\nP Q : MorphismProperty T\nX : T\ninst✝ : Q.IsMultiplicative\nA B : P.Under Q X\nf g : A ⟶ B\nh : f.right = g.right\n⊢ f = g",
"usedConstants": [
"CategoryTheory.MorphismProperty",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",... | ext
· simp
· exact h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.MorphismProperty.Comma | {
"line": 622,
"column": 2
} | {
"line": 624,
"column": 11
} | [
{
"pp": "T : Type u_1\ninst✝¹ : Category.{v_1, u_1} T\nP Q : MorphismProperty T\nX : T\ninst✝ : Q.IsMultiplicative\nA B : P.Under Q X\nf g : A ⟶ B\nh : f.right = g.right\n⊢ f = g",
"usedConstants": [
"CategoryTheory.MorphismProperty",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",... | ext
· simp
· exact h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.MorphismProperty.Comma | {
"line": 621,
"column": 89
} | {
"line": 624,
"column": 11
} | [
{
"pp": "T : Type u_1\ninst✝¹ : Category.{v_1, u_1} T\nP Q : MorphismProperty T\nX : T\ninst✝ : Q.IsMultiplicative\nA B : P.Under Q X\nf g : A ⟶ B\nh : f.right = g.right\n⊢ f = g",
"usedConstants": [
"CategoryTheory.MorphismProperty",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",... | by
ext
· simp
· exact h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.FinitePresentation | {
"line": 176,
"column": 4
} | {
"line": 176,
"column": 35
} | [
{
"pp": "case intro.refine_2\nR : Type w₁\nA : Type w₂\ninst✝⁴ : CommRing R\ninst✝³ : CommRing A\ninst✝² : Algebra R A\ninst✝¹ : FinitePresentation R A\nι : Type v\ninst✝ : Finite ι\nι' : Type v\nw✝ : Fintype ι'\nf : MvPolynomial ι' R →ₐ[R] A\nhf_surj : Surjective ⇑f\nhf_ker : (RingHom.ker f.toRingHom).FG\ng : ... | exact hf_ker.map MvPolynomial.C | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.FinitePresentation | {
"line": 239,
"column": 4
} | {
"line": 239,
"column": 28
} | [
{
"pp": "case refine_2\nR : Type w₁\nA : Type w₂\nB : Type w₃\ninst✝⁸ : CommRing R\ninst✝⁷ : CommRing A\ninst✝⁶ : Algebra R A\ninst✝⁵ : CommRing B\ninst✝⁴ : Algebra R B\ninst✝³ : Algebra A B\ninst✝² : IsScalarTower R A B\ninst✝¹ : FinitePresentation R B\ninst✝ : FiniteType R A\nn : ℕ\nf : MvPolynomial (Fin n) R... | change Ideal.span s₀ = I | Lean.Elab.Tactic.evalChange | Lean.Parser.Tactic.change |
Mathlib.RingTheory.FinitePresentation | {
"line": 278,
"column": 21
} | {
"line": 278,
"column": 29
} | [
{
"pp": "case refine_4\nR : Type w₁\nA : Type w₂\nB : Type w₃\ninst✝⁸ : CommRing R\ninst✝⁷ : CommRing A\ninst✝⁶ : Algebra R A\ninst✝⁵ : CommRing B\ninst✝⁴ : Algebra R B\ninst✝³ : Algebra A B\ninst✝² : IsScalarTower R A B\ninst✝¹ : FinitePresentation R B\ninst✝ : FiniteType R A\nn : ℕ\nf : MvPolynomial (Fin n) R... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Grothendieck | {
"line": 207,
"column": 4
} | {
"line": 208,
"column": 12
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u₁\ninst✝ : Category.{v₁, u₁} D\nF : C ⥤ Cat\nX Y : Grothendieck F\ne₁ : X.base ≅ Y.base\ne₂ : (F.map e₁.hom).toFunctor.obj X.fiber ≅ Y.fiber\n⊢ eqToHom ⋯ ≫\n ({ base := e₁.inv, fiber := (F.map e₁.inv).toFunctor.map e₂.inv ≫ eqToHom ⋯ } ≫\n ... | have := Functor.congr_hom congr($((F.mapIso e₁).inv_hom_id).toFunctor) e₂.inv
simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Grothendieck | {
"line": 207,
"column": 4
} | {
"line": 208,
"column": 12
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u₁\ninst✝ : Category.{v₁, u₁} D\nF : C ⥤ Cat\nX Y : Grothendieck F\ne₁ : X.base ≅ Y.base\ne₂ : (F.map e₁.hom).toFunctor.obj X.fiber ≅ Y.fiber\n⊢ eqToHom ⋯ ≫\n ({ base := e₁.inv, fiber := (F.map e₁.inv).toFunctor.map e₂.inv ≫ eqToHom ⋯ } ≫\n ... | have := Functor.congr_hom congr($((F.mapIso e₁).inv_hom_id).toFunctor) e₂.inv
simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.FinitePresentation | {
"line": 354,
"column": 12
} | {
"line": 354,
"column": 20
} | [
{
"pp": "case refine_4\nR : Type w₁\nA : Type w₂\ninst✝³ : CommRing R\ninst✝² : CommRing A\ninst✝¹ : Algebra R A\nn : ℕ\nf : MvPolynomial (Fin n) R →ₐ[R] A\nhf : Surjective ⇑f\ninst✝ : FinitePresentation R A\nm : ℕ\nf' : MvPolynomial (Fin m) R →ₐ[R] A\nhf' : Surjective ⇑f'\ns : Finset (MvPolynomial (Fin m) R)\n... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.WithTerminal.Basic | {
"line": 296,
"column": 6
} | {
"line": 298,
"column": 12
} | [
{
"pp": "case star.star\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u_1\ninst✝ : Category.{v_1, u_1} D\nZ : D\nF : C ⥤ D\nM : (x : C) → F.obj x ⟶ Z\nhM : ∀ (x y : C) (f : x ⟶ y), F.map f ≫ M y = M x\nG : WithTerminal C ⥤ D\nh : incl ⋙ G ≅ F\nhG : G.obj star ≅ Z\nhh : ∀ (x : C), G.map (starTerminal.from (i... | · cases f
change G.map (𝟙 _) ≫ hG.hom = hG.hom ≫ 𝟙 _
simp | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.FinitePresentation | {
"line": 498,
"column": 10
} | {
"line": 498,
"column": 29
} | [
{
"pp": "P : (R : Type u) → [inst : CommRing R] → (S : Type u) → [inst_1 : CommRing S] → (R →+* S) → Prop\nQ : (R : Type u) → [inst : CommRing R] → (S : Type v) → [inst_1 : CommRing S] → (R →+* S) → Prop\npolynomial : ∀ (R : Type u) [inst : CommRing R], P R R[X] C\nfg_ker :\n ∀ (R : Type u) [inst : CommRing R]... | ← RingHom.comap_ker | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.WithTerminal.Basic | {
"line": 701,
"column": 6
} | {
"line": 703,
"column": 12
} | [
{
"pp": "case star.star\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u_1\ninst✝ : Category.{v_1, u_1} D\nZ : D\nF : C ⥤ D\nM : (x : C) → Z ⟶ F.obj x\nhM : ∀ (x y : C) (f : x ⟶ y), M x ≫ F.map f = M y\nG : WithInitial C ⥤ D\nh : incl ⋙ G ≅ F\nhG : G.obj star ≅ Z\nhh : ∀ (x : C), hG.symm.hom ≫ G.map (starIni... | · cases f
change G.map (𝟙 _) ≫ hG.hom = hG.hom ≫ 𝟙 _
simp | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.CategoryTheory.Limits.Final | {
"line": 473,
"column": 6
} | {
"line": 473,
"column": 15
} | [
{
"pp": "case trans.hbc\nC : Type v\ninst✝¹ : Category.{v, v} C\nD : Type u₁\ninst✝ : Category.{v, u₁} D\nF : C ⥤ D\nd : D\nf₁ f₂ x y z : (X : C) × (d ⟶ F.obj X)\na✝¹ : Relation.EqvGen (F ⋙ coyoneda.obj (op d)).ColimitTypeRel x y\na✝ : Relation.EqvGen (F ⋙ coyoneda.obj (op d)).ColimitTypeRel y z\nih₁ : Zigzag (... | exact ih₂ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Limits.Final | {
"line": 473,
"column": 6
} | {
"line": 473,
"column": 15
} | [
{
"pp": "case trans.hbc\nC : Type v\ninst✝¹ : Category.{v, v} C\nD : Type u₁\ninst✝ : Category.{v, u₁} D\nF : C ⥤ D\nd : D\nf₁ f₂ x y z : (X : C) × (d ⟶ F.obj X)\na✝¹ : Relation.EqvGen (F ⋙ coyoneda.obj (op d)).ColimitTypeRel x y\na✝ : Relation.EqvGen (F ⋙ coyoneda.obj (op d)).ColimitTypeRel y z\nih₁ : Zigzag (... | exact ih₂ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Final | {
"line": 473,
"column": 6
} | {
"line": 473,
"column": 15
} | [
{
"pp": "case trans.hbc\nC : Type v\ninst✝¹ : Category.{v, v} C\nD : Type u₁\ninst✝ : Category.{v, u₁} D\nF : C ⥤ D\nd : D\nf₁ f₂ x y z : (X : C) × (d ⟶ F.obj X)\na✝¹ : Relation.EqvGen (F ⋙ coyoneda.obj (op d)).ColimitTypeRel x y\na✝ : Relation.EqvGen (F ⋙ coyoneda.obj (op d)).ColimitTypeRel y z\nih₁ : Zigzag (... | exact ih₂ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Final | {
"line": 603,
"column": 14
} | {
"line": 604,
"column": 39
} | [
{
"pp": "case h₂\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\nF : C ⥤ D\ninst✝¹ : F.Initial\nE : Type u₃\ninst✝ : Category.{v₃, u₃} E\nG : D ⥤ E\nc : Cone (F ⋙ G)\nX Y : D\nf : X ⟶ Y\nZ₁ Z₂ : C\nk₁ : F.obj Z₁ ⟶ Y\nk₂ : F.obj Z₂ ⟶ Y\ng : Z₁ ⟶ Z₂\na : F.map g ≫ k₂ = k₁\nz... | rw [← a, Functor.map_comp, ← Functor.comp_map, ← Category.assoc, ← Category.assoc,
c.w, z, Category.assoc] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.EffectiveEpi.Basic | {
"line": 272,
"column": 15
} | {
"line": 274,
"column": 15
} | [
{
"pp": "C : Type u_1\ninst✝ : Category.{v_1, u_1} C\nB : C\nα : Type u_2\nα' : Type u_3\nX : α → C\nπ : (a : α) → X a ⟶ B\ne : α' ≃ α\nP : EffectiveEpiFamilyStruct (fun a ↦ X (e a)) fun a ↦ π (e a)\nW✝ : C\nx✝¹ : (a : α) → X a ⟶ W✝\nx✝ : ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂), g₁ ≫ π a₁ = g₂ ≫ π... | by
obtain ⟨a, rfl⟩ := e.surjective a
apply P.fac | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Final | {
"line": 626,
"column": 2
} | {
"line": 629,
"column": 17
} | [
{
"pp": "case h₁\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\nF : C ⥤ D\ninst✝¹ : F.Initial\nE : Type u₃\ninst✝ : Category.{v₃, u₃} E\nG : D ⥤ E\ns : Cone (F ⋙ G)\nj : C\n⊢ ∀ (X₁ X₂ : C) (k₁ : F.obj X₁ ⟶ F.obj j) (k₂ : F.obj X₂ ⟶ F.obj j) (f : X₁ ⟶ X₂),\n F.map f ≫ k... | · intro j₁ j₂ k₁ k₂ f w h
rw [← s.w f]
rw [← w] at h
simpa using h | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | {
"line": 210,
"column": 25
} | {
"line": 210,
"column": 44
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nJ : Type u₂\ninst✝ : Category.{v₂, u₂} J\nX Y : C\nf g : X ⟶ Y\nc : Fork f g\n⊢ (Iso.refl c.op.unop.pt).hom ≫ c.ι = c.op.unop.ι",
"usedConstants": [
"CategoryTheory.Limits.Cofork.unop",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Ho... | by simp [op_unop_ι] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Final | {
"line": 870,
"column": 78
} | {
"line": 886,
"column": 80
} | [
{
"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\nF : C ⥤ D\nG : D ⥤ E\nhF : F.Final\nhFG : (F ⋙ G).Final\n⊢ G.Final",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Equivalence.isEquivalence_inverse",
"Ca... | by
let s₁ : C ≌ AsSmall.{max u₁ v₁ u₂ v₂ u₃ v₃} C := AsSmall.equiv
let s₂ : D ≌ AsSmall.{max u₁ v₁ u₂ v₂ u₃ v₃} D := AsSmall.equiv
let s₃ : E ≌ AsSmall.{max u₁ v₁ u₂ v₂ u₃ v₃} E := AsSmall.equiv
let _i : s₁.inverse ⋙ (F ⋙ G) ⋙ s₃.functor ≅
(s₁.inverse ⋙ F ⋙ s₂.functor) ⋙ (s₂.inverse ⋙ G ⋙ s₃.functor) :=
... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | {
"line": 346,
"column": 9
} | {
"line": 346,
"column": 30
} | [
{
"pp": "C : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nJ : Type u₂\ninst✝² : Category.{v₂, u₂} J\nX Y : Cᵒᵖ\nf : X ⟶ Y\ninst✝¹ : HasPullback f f\ninst✝ : HasPushout f.unop f.unop\nh : IsColimit (ofπ f ⋯)\n⊢ (Iso.refl (Opposite.unop X)).hom ≫ pushout.inl f.unop f.unop =\n (pullback.fst f f).unop ≫ (pullbackIsoOp... | by simp [← unop_comp] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | {
"line": 346,
"column": 33
} | {
"line": 346,
"column": 54
} | [
{
"pp": "C : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nJ : Type u₂\ninst✝² : Category.{v₂, u₂} J\nX Y : Cᵒᵖ\nf : X ⟶ Y\ninst✝¹ : HasPullback f f\ninst✝ : HasPushout f.unop f.unop\nh : IsColimit (ofπ f ⋯)\n⊢ (Iso.refl (Opposite.unop X)).hom ≫ pushout.inr f.unop f.unop =\n (pullback.snd f f).unop ≫ (pullbackIsoOp... | by simp [← unop_comp] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.RingHomProperties | {
"line": 117,
"column": 4
} | {
"line": 119,
"column": 21
} | [
{
"pp": "case right\nP : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop\nhP : StableUnderComposition P\nhP' : ∀ {R S : Type u} [inst : CommRing R] [inst_1 : CommRing S] (e : R ≃+* S), P e.toRingHom\n⊢ ∀ {R S T : Type u} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRin... | introv H
apply hP
exacts [hP' e, H] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.RingHomProperties | {
"line": 117,
"column": 4
} | {
"line": 119,
"column": 21
} | [
{
"pp": "case right\nP : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop\nhP : StableUnderComposition P\nhP' : ∀ {R S : Type u} [inst : CommRing R] [inst_1 : CommRing S] (e : R ≃+* S), P e.toRingHom\n⊢ ∀ {R S T : Type u} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRin... | introv H
apply hP
exacts [hP' e, H] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.MorphismProperty.Limits | {
"line": 375,
"column": 2
} | {
"line": 384,
"column": 57
} | [
{
"pp": "C : Type u\ninst✝⁴ : Category.{v, u} C\nP : MorphismProperty C\ninst✝³ : P.IsStableUnderCobaseChange\ninst✝² : P.IsStableUnderComposition\nS X X' Y Y' : C\nf : S ⟶ X\ng : S ⟶ Y\nf' : S ⟶ X'\ng' : S ⟶ Y'\ni₁ : X ⟶ X'\ninst✝¹ : HasPushoutsAlong f\ninst✝ : HasPushoutsAlong g'\ni₂ : Y ⟶ Y'\nh₁ : P i₁\nh₂ :... | have : HasPushoutsAlong (Under.mk g').hom := by cat_disch
have : pushout.map f g f' g' i₁ i₂ (𝟙 _) (by simp [e₁]) (by simp [e₂]) =
((pushoutSymmetry _ _).hom ≫
((Under.pushout f).map (Under.homMk _ e₂.symm : Under.mk g ⟶ Under.mk g')).right) ≫
(pushoutSymmetry _ _).hom ≫
((Under.pushout... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.MorphismProperty.Limits | {
"line": 375,
"column": 2
} | {
"line": 384,
"column": 57
} | [
{
"pp": "C : Type u\ninst✝⁴ : Category.{v, u} C\nP : MorphismProperty C\ninst✝³ : P.IsStableUnderCobaseChange\ninst✝² : P.IsStableUnderComposition\nS X X' Y Y' : C\nf : S ⟶ X\ng : S ⟶ Y\nf' : S ⟶ X'\ng' : S ⟶ Y'\ni₁ : X ⟶ X'\ninst✝¹ : HasPushoutsAlong f\ninst✝ : HasPushoutsAlong g'\ni₂ : Y ⟶ Y'\nh₁ : P i₁\nh₂ :... | have : HasPushoutsAlong (Under.mk g').hom := by cat_disch
have : pushout.map f g f' g' i₁ i₂ (𝟙 _) (by simp [e₁]) (by simp [e₂]) =
((pushoutSymmetry _ _).hom ≫
((Under.pushout f).map (Under.homMk _ e₂.symm : Under.mk g ⟶ Under.mk g')).right) ≫
(pushoutSymmetry _ _).hom ≫
((Under.pushout... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.ObjectProperty.Small | {
"line": 135,
"column": 4
} | {
"line": 136,
"column": 56
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nD : Type u'\ninst✝¹ : Category.{v', u'} D\nP : ObjectProperty C\ninst✝ : ObjectProperty.EssentiallySmall.{w, v, u} P\n⊢ ∃ Q, ∃ (_ : ObjectProperty.Small.{w, v, u} Q), P.isoClosure ≤ Q.isoClosure",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Objec... | obtain ⟨Q, _, _, _⟩ := EssentiallySmall.exists_small_le.{w} P
exact ⟨Q, inferInstance, by rwa [isoClosure_le_iff]⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.ObjectProperty.Small | {
"line": 135,
"column": 4
} | {
"line": 136,
"column": 56
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nD : Type u'\ninst✝¹ : Category.{v', u'} D\nP : ObjectProperty C\ninst✝ : ObjectProperty.EssentiallySmall.{w, v, u} P\n⊢ ∃ Q, ∃ (_ : ObjectProperty.Small.{w, v, u} Q), P.isoClosure ≤ Q.isoClosure",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Objec... | obtain ⟨Q, _, _, _⟩ := EssentiallySmall.exists_small_le.{w} P
exact ⟨Q, inferInstance, by rwa [isoClosure_le_iff]⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.MorphismProperty.Limits | {
"line": 717,
"column": 4
} | {
"line": 718,
"column": 69
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nW : MorphismProperty C\nJ : Type u_1\ninst✝ : W.RespectsIso\nhW :\n ∀ (X₁ X₂ : J → C) [inst : HasProduct X₁] [inst_1 : HasProduct X₂] (f : (j : J) → X₁ j ⟶ X₂ j),\n (∀ (j : J), W (f j)) → W (Limits.Pi.map f)\nX₁ X₂ : Discrete J ⥤ C\nc₁ : Cone X₁\nc₂ : Cone X₂... | have : HasProduct fun j ↦ X₂.obj (Discrete.mk j) :=
hasLimit_of_iso (Discrete.natIso (fun j ↦ Iso.refl (X₂.obj j))) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.CategoryTheory.ObjectProperty.Small | {
"line": 199,
"column": 2
} | {
"line": 202,
"column": 51
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\nD : Type u'\ninst✝² : Category.{v', u'} D\nP : ObjectProperty C\ninst✝¹ : LocallySmall.{w, v, u} C\ninst✝ : ObjectProperty.EssentiallySmall.{w, v, u} P\n⊢ EssentiallySmall.{w, v, u} P.FullSubcategory",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
... | obtain ⟨Q, _, h₁, h₂⟩ := EssentiallySmall.exists_small_le P
have := (isEquivalence_ιOfLE_iff h₁).2 h₂
rw [← essentiallySmall_congr (ιOfLE h₁).asEquivalence]
exact essentiallySmall_of_small_of_locallySmall _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.ObjectProperty.Small | {
"line": 199,
"column": 2
} | {
"line": 202,
"column": 51
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\nD : Type u'\ninst✝² : Category.{v', u'} D\nP : ObjectProperty C\ninst✝¹ : LocallySmall.{w, v, u} C\ninst✝ : ObjectProperty.EssentiallySmall.{w, v, u} P\n⊢ EssentiallySmall.{w, v, u} P.FullSubcategory",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
... | obtain ⟨Q, _, h₁, h₂⟩ := EssentiallySmall.exists_small_le P
have := (isEquivalence_ιOfLE_iff h₁).2 h₂
rw [← essentiallySmall_congr (ιOfLE h₁).asEquivalence]
exact essentiallySmall_of_small_of_locallySmall _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.ObjectProperty.Small | {
"line": 223,
"column": 2
} | {
"line": 226,
"column": 51
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\nD : Type u'\ninst✝² : Category.{v', u'} D\nP : ObjectProperty C\ninst✝¹ : LocallySmall.{w, v, u} C\ninst✝ : ObjectProperty.EssentiallySmall.{w, v, u} P\n⊢ EssentiallySmall.{w, v, u} P.FullSubcategory",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
... | obtain ⟨Q, _, h₁, h₂⟩ := EssentiallySmall.exists_small_le P
have := (isEquivalence_ιOfLE_iff h₁).2 h₂
rw [← essentiallySmall_congr (ιOfLE h₁).asEquivalence]
exact essentiallySmall_of_small_of_locallySmall _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.ObjectProperty.Small | {
"line": 223,
"column": 2
} | {
"line": 226,
"column": 51
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\nD : Type u'\ninst✝² : Category.{v', u'} D\nP : ObjectProperty C\ninst✝¹ : LocallySmall.{w, v, u} C\ninst✝ : ObjectProperty.EssentiallySmall.{w, v, u} P\n⊢ EssentiallySmall.{w, v, u} P.FullSubcategory",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
... | obtain ⟨Q, _, h₁, h₂⟩ := EssentiallySmall.exists_small_le P
have := (isEquivalence_ιOfLE_iff h₁).2 h₂
rw [← essentiallySmall_congr (ιOfLE h₁).asEquivalence]
exact essentiallySmall_of_small_of_locallySmall _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Diagonal | {
"line": 401,
"column": 64
} | {
"line": 401,
"column": 72
} | [
{
"pp": "case h₀\nC : Type u_1\ninst✝¹ : Category.{v_1, u_1} C\nX Y : C\ninst✝ : HasPullbacks C\nS : C\ng : Y ⟶ X\nf : X ⟶ S\ni : pullback (g ≫ f) f ≅ pullback (g ≫ f) (𝟙 X ≫ f) := ⋯\n⊢ (map (g ≫ f) (𝟙 X ≫ f) f f g (𝟙 X) (𝟙 S) ⋯ ⋯ ≫ 𝟙 (diagonalObj f)) ≫ fst f f =\n (i.inv ≫ map (g ≫ f) f f f g (𝟙 X) (�... | simp [i] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Shapes.Diagonal | {
"line": 401,
"column": 64
} | {
"line": 401,
"column": 72
} | [
{
"pp": "case h₁\nC : Type u_1\ninst✝¹ : Category.{v_1, u_1} C\nX Y : C\ninst✝ : HasPullbacks C\nS : C\ng : Y ⟶ X\nf : X ⟶ S\ni : pullback (g ≫ f) f ≅ pullback (g ≫ f) (𝟙 X ≫ f) := ⋯\n⊢ (map (g ≫ f) (𝟙 X ≫ f) f f g (𝟙 X) (𝟙 S) ⋯ ⋯ ≫ 𝟙 (diagonalObj f)) ≫ snd f f =\n (i.inv ≫ map (g ≫ f) f f f g (𝟙 X) (�... | simp [i] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | {
"line": 345,
"column": 2
} | {
"line": 345,
"column": 48
} | [
{
"pp": "C : Type u_1\nD : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_2, u_2} D\nP : ObjectProperty C\nJ : Type u'\ninst✝² : Category.{v', u'} J\nJ' : Type u''\ninst✝¹ : Category.{v'', u''} J'\ninst✝ : P.IsClosedUnderColimitsOfShape Jᵒᵖ\n⊢ P.op.IsClosedUnderLimitsOfShape J",
"usedConstan... | rwa [← isClosedUnderColimitsOfShape_op_iff_op] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | {
"line": 345,
"column": 2
} | {
"line": 345,
"column": 48
} | [
{
"pp": "C : Type u_1\nD : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_2, u_2} D\nP : ObjectProperty C\nJ : Type u'\ninst✝² : Category.{v', u'} J\nJ' : Type u''\ninst✝¹ : Category.{v'', u''} J'\ninst✝ : P.IsClosedUnderColimitsOfShape Jᵒᵖ\n⊢ P.op.IsClosedUnderLimitsOfShape J",
"usedConstan... | rwa [← isClosedUnderColimitsOfShape_op_iff_op] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | {
"line": 345,
"column": 2
} | {
"line": 345,
"column": 48
} | [
{
"pp": "C : Type u_1\nD : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_2, u_2} D\nP : ObjectProperty C\nJ : Type u'\ninst✝² : Category.{v', u'} J\nJ' : Type u''\ninst✝¹ : Category.{v'', u''} J'\ninst✝ : P.IsClosedUnderColimitsOfShape Jᵒᵖ\n⊢ P.op.IsClosedUnderLimitsOfShape J",
"usedConstan... | rwa [← isClosedUnderColimitsOfShape_op_iff_op] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {
"line": 218,
"column": 52
} | {
"line": 218,
"column": 66
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\n𝒯 : LimitCone (Functor.empty C)\nℬ : (X Y : C) → LimitCone (pair X Y)\nX₁ X₂ X₃ Y₁ Y₂ Y₃ Z₁ Z₂ : C\nthis : MonoidalCategoryStruct C :=\n { tensorObj := ofChosenFiniteProducts.tensorObj ℬ,\n whiskerLeft := fun X {x x_1} g ↦ ofChosenFiniteProducts.tensorHom ℬ (... | simpa using hf | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {
"line": 218,
"column": 52
} | {
"line": 218,
"column": 66
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\n𝒯 : LimitCone (Functor.empty C)\nℬ : (X Y : C) → LimitCone (pair X Y)\nX₁ X₂ X₃ Y₁ Y₂ Y₃ Z₁ Z₂ : C\nthis : MonoidalCategoryStruct C :=\n { tensorObj := ofChosenFiniteProducts.tensorObj ℬ,\n whiskerLeft := fun X {x x_1} g ↦ ofChosenFiniteProducts.tensorHom ℬ (... | simpa using hf | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {
"line": 218,
"column": 52
} | {
"line": 218,
"column": 66
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\n𝒯 : LimitCone (Functor.empty C)\nℬ : (X Y : C) → LimitCone (pair X Y)\nX₁ X₂ X₃ Y₁ Y₂ Y₃ Z₁ Z₂ : C\nthis : MonoidalCategoryStruct C :=\n { tensorObj := ofChosenFiniteProducts.tensorObj ℬ,\n whiskerLeft := fun X {x x_1} g ↦ ofChosenFiniteProducts.tensorHom ℬ (... | simpa using hf | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {
"line": 710,
"column": 87
} | {
"line": 712,
"column": 16
} | [
{
"pp": "C✝ : Type u\ninst✝⁹ : Category.{v, u} C✝\nC : Type u\ninst✝⁸ : Category.{v, u} C\ninst✝⁷ : CartesianMonoidalCategory C\nD : Type u₁\ninst✝⁶ : Category.{v₁, u₁} D\ninst✝⁵ : CartesianMonoidalCategory D\nF : C ⥤ D\nE✝ : Type u₂\ninst✝⁴ : Category.{v₂, u₂} E✝\ninst✝³ : CartesianMonoidalCategory E✝\nG✝ : D ... | by
rw [← prodComparisonIso_hom]
infer_instance | [anonymous] | Lean.Parser.Term.byTactic |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.