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.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 241,
"column": 2
} | {
"line": 244,
"column": 95
} | [
{
"pp": "m : Type u_1\nn : Type u_2\ninst✝⁶ : DecidableEq n\ninst✝⁵ : Fintype n\ninst✝⁴ : DecidableEq m\ninst✝³ : Fintype m\nR : Type u_3\ninst✝² : CommRing R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\ne₁ e₂ : n ≃ m\nA : Matrix m m R\n⊢ |(A.submatrix ⇑e₁ ⇑e₂).det| = |A.det|",
"usedConstants": [... | have hee : e₂ = e₁.trans (e₁.symm.trans e₂) := by ext; simp
rw [hee]
change |((A.submatrix id (e₁.symm.trans e₂)).submatrix e₁ e₁).det| = |A.det|
rw [Matrix.det_submatrix_equiv_self, Matrix.det_permute', abs_mul, abs_unit_intCast, one_mul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 513,
"column": 2
} | {
"line": 514,
"column": 23
} | [
{
"pp": "n : Type u_2\ninst✝³ : DecidableEq n\ninst✝² : Fintype n\nR : Type v\ninst✝¹ : CommRing R\ninst✝ : Nontrivial n\nu v : n → R\ni j : n\nhij : i ≠ j\nuv' : Matrix n n R := ((vecMulVec u v).updateRow i v).updateRow j v\nhuv' : uv'.det = 0\nthis : vecMulVec u v = (uv'.updateRow i (u i • uv' i)).updateRow j... | rw [this, det_updateRow_smul, updateRow_eq_self, det_updateRow_smul, updateRow_eq_self, huv',
mul_zero, mul_zero] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Category.ModuleCat.Limits | {
"line": 115,
"column": 2
} | {
"line": 117,
"column": 7
} | [
{
"pp": "case refine_1\nR : Type u\ninst✝² : Ring R\nJ : Type v\ninst✝¹ : Category.{t, v} J\nF : J ⥤ ModuleCat R\ninst✝ : Small.{w, max v w} ↑(F ⋙ forget (ModuleCat R)).sections\ns : Cone F\n⊢ ∀ (x y : ↑s.1),\n (ConcreteCategory.hom\n ((Types.Small.limitConeIsLimit (F ⋙ forget (ModuleCat R))).lift (... | · intro x y
simp [← equivShrink_add]
rfl | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Category.ModuleCat.Limits | {
"line": 189,
"column": 6
} | {
"line": 189,
"column": 71
} | [
{
"pp": "R : Type u\ninst✝¹ : Ring R\nJ : Type v\ninst✝ : Category.{t, v} J\nF : J ⥤ ModuleCat R\nc : Cone F\nhc : IsLimit ((forget₂ (ModuleCat R) AddCommGrpCat).mapCone c)\nthis : HasLimit (F ⋙ forget₂ (ModuleCat R) AddCommGrpCat)\n⊢ Small.{w, max v w} ↑(F ⋙ forget (ModuleCat R)).sections",
"usedConstants"... | simpa only [AddCommGrpCat.hasLimit_iff_small_sections] using this | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.CategoryTheory.Monoidal.Preadditive | {
"line": 256,
"column": 76
} | {
"line": 260,
"column": 48
} | [
{
"pp": "C : Type u_1\ninst✝⁵ : Category.{v_1, u_1} C\ninst✝⁴ : Preadditive C\ninst✝³ : MonoidalCategory C\ninst✝² : MonoidalPreadditive C\ninst✝¹ : HasFiniteBiproducts C\nJ : Type\ninst✝ : Finite J\nf : J → C\nX : C\nj : J\n⊢ (rightDistributor f X).inv ≫ biproduct.π f j ▷ X = biproduct.π (fun j ↦ f j ⊗ X) j",
... | by
classical
cases nonempty_fintype J
simp [rightDistributor_inv, Preadditive.sum_comp, ← comp_whiskerRight,
biproduct.ι_π, dite_whiskerRight, comp_dite] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Category.Ring.Limits | {
"line": 106,
"column": 2
} | {
"line": 108,
"column": 7
} | [
{
"pp": "case refine_4\nJ : Type v\ninst✝¹ : Category.{w, v} J\nF : J ⥤ SemiRingCat\ninst✝ : Small.{u, max u v} ↑(F ⋙ forget SemiRingCat).sections\ns : Cone F\n⊢ ∀ (x y : ↑s.1),\n EquivLike.coe (equivShrink ↑(F ⋙ forget SemiRingCat).sections)\n ⟨fun j ↦ (ConcreteCategory.hom (((forget SemiRingCat).map... | · intro x y
simp [← equivShrink_add]
rfl | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 858,
"column": 6
} | {
"line": 859,
"column": 41
} | [
{
"pp": "case h₁\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✝ F : C ⥤ D\nG : C ⥤ E\ninst✝... | simp only [CategoryTheory.prod_comp_fst, prod'_ε_fst, prod'_η_fst, ε_η,
prodMonoidal_tensorUnit, prod_id] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 858,
"column": 6
} | {
"line": 859,
"column": 41
} | [
{
"pp": "case h₁\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✝ F : C ⥤ D\nG : C ⥤ E\ninst✝... | simp only [CategoryTheory.prod_comp_fst, prod'_ε_fst, prod'_η_fst, ε_η,
prodMonoidal_tensorUnit, prod_id] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 858,
"column": 6
} | {
"line": 859,
"column": 41
} | [
{
"pp": "case h₁\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✝ F : C ⥤ D\nG : C ⥤ E\ninst✝... | simp only [CategoryTheory.prod_comp_fst, prod'_ε_fst, prod'_η_fst, ε_η,
prodMonoidal_tensorUnit, prod_id] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 1162,
"column": 2
} | {
"line": 1165,
"column": 60
} | [
{
"pp": "C : Type u₁\ninst✝⁶ : Category.{v₁, u₁} C\ninst✝⁵ : MonoidalCategory C\nD : Type u₂\ninst✝⁴ : Category.{v₂, u₂} D\ninst✝³ : MonoidalCategory D\ne : C ≌ D\ninst✝² : e.functor.Monoidal\ninst✝¹ : e.inverse.Monoidal\ninst✝ : e.IsMonoidal\nX Y : C\n⊢ e.counitIso.inv.app (e.functor.obj X ⊗ e.functor.obj Y) ≫... | rw [← cancel_epi (δ e.functor _ _), Monoidal.δ_μ_assoc]
apply e.inverse.map_injective
simp [← cancel_epi (e.unitIso.hom.app (X ⊗ Y)), Functor.map_comp,
unitIso_hom_app_tensor_comp_inverse_map_δ_functor_assoc] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Monoidal.Functor | {
"line": 1162,
"column": 2
} | {
"line": 1165,
"column": 60
} | [
{
"pp": "C : Type u₁\ninst✝⁶ : Category.{v₁, u₁} C\ninst✝⁵ : MonoidalCategory C\nD : Type u₂\ninst✝⁴ : Category.{v₂, u₂} D\ninst✝³ : MonoidalCategory D\ne : C ≌ D\ninst✝² : e.functor.Monoidal\ninst✝¹ : e.inverse.Monoidal\ninst✝ : e.IsMonoidal\nX Y : C\n⊢ e.counitIso.inv.app (e.functor.obj X ⊗ e.functor.obj Y) ≫... | rw [← cancel_epi (δ e.functor _ _), Monoidal.δ_μ_assoc]
apply e.inverse.map_injective
simp [← cancel_epi (e.unitIso.hom.app (X ⊗ Y)), Functor.map_comp,
unitIso_hom_app_tensor_comp_inverse_map_δ_functor_assoc] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Braided.Basic | {
"line": 92,
"column": 45
} | {
"line": 95,
"column": 24
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\ninst✝ : BraidedCategory C\nX Y Z : C\n⊢ (β_ (X ⊗ Y) Z).hom = (α_ X Y Z).hom ≫ X ◁ (β_ Y Z).hom ≫ (α_ X Z Y).inv ≫ (β_ X Z).hom ▷ Y ≫ (α_ Z X Y).hom",
"usedConstants": [
"CategoryTheory.Category.assoc",
"CategoryTheory.... | by
apply (cancel_epi (α_ X Y Z).inv).1
apply (cancel_mono (α_ Z X Y).inv).1
simp [hexagon_reverse] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Monoidal.Braided.Basic | {
"line": 557,
"column": 75
} | {
"line": 557,
"column": 91
} | [
{
"pp": "C : Type u₁\ninst✝⁵ : Category.{v₁, u₁} C\ninst✝⁴ : MonoidalCategory C\ninst✝³ : BraidedCategory C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\ninst✝¹ : MonoidalCategory D\ninst✝ : BraidedCategory D\nF : C ⥤ D\n⊢ Function.Injective (@toMonoidal C inst✝⁵ inst✝⁴ inst✝³ D inst✝² inst✝¹ inst✝ F)",
"used... | rintro ⟨⟩ ⟨⟩ rfl | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.RingTheory.Coalgebra.Basic | {
"line": 274,
"column": 4
} | {
"line": 278,
"column": 87
} | [
{
"pp": "R : Type u\nA : Type v\nB : Type w\ninst✝⁶ : CommSemiring R\ninst✝⁵ : AddCommMonoid A\ninst✝⁴ : AddCommMonoid B\ninst✝³ : Module R A\ninst✝² : Module R B\ninst✝¹ : Coalgebra R A\ninst✝ : Coalgebra R B\n⊢ rTensor (A × B) counit ∘ₗ comul = (TensorProduct.mk R R (A × B)) 1",
"usedConstants": [
"... | ext : 1
· rw [comp_assoc, comul_comp_inl, ← comp_assoc, rTensor_comp_map, counit_comp_inl,
← lTensor_comp_rTensor, comp_assoc, rTensor_counit_comp_comul, lTensor_comp_mk]
· rw [comp_assoc, comul_comp_inr, ← comp_assoc, rTensor_comp_map, counit_comp_inr,
← lTensor_comp_rTensor, comp_assoc, rTenso... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Coalgebra.Basic | {
"line": 274,
"column": 4
} | {
"line": 278,
"column": 87
} | [
{
"pp": "R : Type u\nA : Type v\nB : Type w\ninst✝⁶ : CommSemiring R\ninst✝⁵ : AddCommMonoid A\ninst✝⁴ : AddCommMonoid B\ninst✝³ : Module R A\ninst✝² : Module R B\ninst✝¹ : Coalgebra R A\ninst✝ : Coalgebra R B\n⊢ rTensor (A × B) counit ∘ₗ comul = (TensorProduct.mk R R (A × B)) 1",
"usedConstants": [
"... | ext : 1
· rw [comp_assoc, comul_comp_inl, ← comp_assoc, rTensor_comp_map, counit_comp_inl,
← lTensor_comp_rTensor, comp_assoc, rTensor_counit_comp_comul, lTensor_comp_mk]
· rw [comp_assoc, comul_comp_inr, ← comp_assoc, rTensor_comp_map, counit_comp_inr,
← lTensor_comp_rTensor, comp_assoc, rTenso... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Braided.Basic | {
"line": 712,
"column": 90
} | {
"line": 719,
"column": 13
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{v₁, u₁} C\ninst✝¹ : MonoidalCategory C\ninst✝ : BraidedCategory C\nX₁ X₂ : C\n⊢ (λ_ X₁).hom ⊗ₘ (λ_ X₂).hom = tensorμ (𝟙_ C) X₁ (𝟙_ C) X₂ ≫ (λ_ (𝟙_ C)).hom ▷ (X₁ ⊗ X₂) ≫ (λ_ (X₁ ⊗ X₂)).hom",
"usedConstants": [
"Mathlib.Tactic.Monoidal.eval_tensorHom",
"... | by
dsimp only [tensorμ]
have :
(λ_ X₁).hom ⊗ₘ (λ_ X₂).hom =
(α_ (𝟙_ C) X₁ (𝟙_ C ⊗ X₂)).hom ≫
(𝟙_ C ◁ (α_ X₁ (𝟙_ C) X₂).inv) ≫ (λ_ ((X₁ ⊗ 𝟙_ C) ⊗ X₂)).hom ≫ ((ρ_ X₁).hom ▷ X₂) := by
monoidal
simp [this] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Adjunction.Unique | {
"line": 60,
"column": 2
} | {
"line": 63,
"column": 19
} | [
{
"pp": "case w.h\nC : Type u_1\nD : Type u_2\ninst✝¹ : Category.{v_1, u_1} C\ninst✝ : Category.{v_2, u_2} D\nF F' : C ⥤ D\nG : D ⥤ C\nadj1 : F ⊣ G\nadj2 : F' ⊣ G\nx : D\n⊢ (G.whiskerLeft (adj1.leftAdjointUniq adj2).hom ≫ adj2.counit).app x = adj1.counit.app x",
"usedConstants": [
"Eq.mpr",
"Cat... | simp only [Functor.comp_obj, Functor.id_obj, leftAdjointUniq, Iso.symm_hom,
conjugateIsoEquiv_symm_apply_inv, Iso.refl_inv, NatTrans.comp_app, whiskerLeft_app,
conjugateEquiv_symm_apply_app, NatTrans.id_app, Functor.map_id, Category.id_comp,
Category.assoc] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Adjunction.Mates | {
"line": 177,
"column": 2
} | {
"line": 179,
"column": 47
} | [
{
"pp": "case h\nA : 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 ⥤ C\nG₂ : C ⥤ E\nH₁ : B ⥤ D\nH₂... | slice_rhs 2 4 =>
rw [← R₃.map_comp, ← R₃.map_comp, ← assoc, ← L₃.map_comp, ← G₂.map_comp, ← G₂.map_comp]
rw [← Functor.comp_map G₂ L₃, β.naturality] | Mathlib.Tactic.Slice._aux_Mathlib_Tactic_CategoryTheory_Slice___macroRules_Mathlib_Tactic_Slice_sliceRHS_1 | Mathlib.Tactic.Slice.sliceRHS |
Mathlib.CategoryTheory.Adjunction.Mates | {
"line": 506,
"column": 57
} | {
"line": 511,
"column": 6
} | [
{
"pp": "A : Type u₁\nB : Type u₂\nC : Type u₃\nD : Type u₄\ninst✝³ : Category.{v₁, u₁} A\ninst✝² : Category.{v₂, u₂} B\ninst✝¹ : Category.{v₃, u₃} C\ninst✝ : Category.{v₄, u₄} D\nL₀₁ : A ⥤ B\nR₁₀ : B ⥤ A\nL₁₂ : B ⥤ C\nR₂₁ : C ⥤ B\nL₂₃ : C ⥤ D\nR₃₂ : D ⥤ C\nadj₀₁ : L₀₁ ⊣ R₁₀\nadj₁₂ : L₁₂ ⊣ R₂₁\nadj₂₃ : L₂₃ ⊣ R₃... | by
ext X
simp only [comp_obj, conjugateEquiv_apply_app, Adjunction.comp_unit_app, id_obj,
Functor.comp_map, Category.assoc, ← map_comp, associator_hom_app, map_id,
Adjunction.comp_counit_app, Category.id_comp]
simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Monoidal.Comon_ | {
"line": 282,
"column": 46
} | {
"line": 282,
"column": 58
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\ninst✝³ : MonoidalCategory C\nM N O : C\ninst✝² : ComonObj M\ninst✝¹ : ComonObj N\ninst✝ : ComonObj O\nA : Mon Cᵒᵖ\n⊢ μ.unop ≫ (η ▷ A.X).unop = (λ_ (unop A.X)).inv",
"usedConstants": [
"Eq.mpr",
"Opposite",
"CategoryTheory.CategoryStruct.t... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Monoidal.Comon_ | {
"line": 283,
"column": 45
} | {
"line": 283,
"column": 57
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\ninst✝³ : MonoidalCategory C\nM N O : C\ninst✝² : ComonObj M\ninst✝¹ : ComonObj N\ninst✝ : ComonObj O\nA : Mon Cᵒᵖ\n⊢ μ.unop ≫ (A.X ◁ η).unop = (ρ_ (unop A.X)).inv",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Monoidal.Comon_ | {
"line": 285,
"column": 68
} | {
"line": 285,
"column": 80
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\ninst✝³ : MonoidalCategory C\nM N O : C\ninst✝² : ComonObj M\ninst✝¹ : ComonObj N\ninst✝ : ComonObj O\nA : Mon Cᵒᵖ\n⊢ μ.unop ≫ (A.X ◁ μ).unop = (μ ▷ A.X ≫ μ).unop ≫ (α_ (unop A.X) (unop A.X) (unop A.X)).hom",
"usedConstants": [
"Eq.mpr",
"Catego... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.TwoSidedIdeal.Operations | {
"line": 70,
"column": 10
} | {
"line": 70,
"column": 11
} | [
{
"pp": "R : Type u_1\ninst✝ : NonUnitalNonAssocRing R\ns : Set R\nx : R\nh : x ∈ { ringCon := sInf {s_1 | ∀ (x y : R), x - y ∈ s → s_1 x y} }\n⊢ ∀ (I : TwoSidedIdeal R), s ⊆ ↑I → x ∈ I",
"usedConstants": [
"TwoSidedIdeal"
]
}
] | I | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.RingTheory.Coalgebra.CoassocSimps | {
"line": 675,
"column": 2
} | {
"line": 677,
"column": 52
} | [
{
"pp": "R : Type u_1\nM : Type u_3\nN : Type u_4\ninst✝⁵ : CommSemiring R\ninst✝⁴ : AddCommMonoid M\ninst✝³ : Module R M\ninst✝² : AddCommMonoid N\ninst✝¹ : Module R N\ninst✝ : Coalgebra R M\nf : M →ₗ[R] N\n⊢ α ∘ₗ (β ∘ₗ δ) ⊗ₘ f ∘ₗ δ = LinearMap.id ⊗ₘ (LinearMap.id ⊗ₘ f ∘ₗ β) ∘ₗ α ∘ₗ δ ⊗ₘ LinearMap.id ∘ₗ β ∘ₗ δ... | rw [← symm_comp_map_assoc, ← LinearMap.lTensor_def, ← LinearMap.lTensor_def,
← LinearMap.lTensor_def, ← Coalgebra.coassoc, ← f.comp_id,
TensorProduct.map_comp, ← LinearMap.rTensor_def] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Localization.Away.Basic | {
"line": 500,
"column": 2
} | {
"line": 500,
"column": 19
} | [
{
"pp": "R : Type u_1\ninst✝¹ : CommSemiring R\nS : Type u_2\ninst✝ : CommSemiring S\nf : R →+* S\na : R\nH : ∀ (a_1 : S), ∃ b m, f b = f a ^ m * a_1\nb : R\n⊢ ∀ (a_1 : S), ∃ b_1 m, f b_1 = f (a * b) ^ m * a_1",
"usedConstants": []
}
] | refine fun x ↦ ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.RingTheory.Localization.Away.Basic | {
"line": 582,
"column": 2
} | {
"line": 583,
"column": 59
} | [
{
"pp": "R : Type u_1\ninst✝ : CommSemiring R\ns : Finset R\nf : (a : ↑↑s) → Away ↑a\nh : ∀ (a b : ↑↑s), (Away.awayToAwayRight ↑a ↑b) (f a) = (Away.awayToAwayLeft ↑b ↑a) (f b)\nmem : 1 ∈ Ideal.span ↑s\nspan_eq : Ideal.span ↑s = ⊤\nn : ↑↑s → ℕ\nr✝¹ : ↑↑s → R\neq✝ : ∀ (a : ↑↑s), f a * (algebraMap R (Away ↑a)) ↑a ... | have eq a : f a * algebraMap R _ (a ^ N) = algebraMap R _ (r a) := by
rw [map_mul, ← eq, mul_left_comm, ← map_mul, ← pow_add] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.Localization.Away.Basic | {
"line": 688,
"column": 2
} | {
"line": 691,
"column": 74
} | [
{
"pp": "case mpr\nR : Type u_1\ninst✝³ : CommSemiring R\nx : R\nB : Type u_2\ninst✝² : CommSemiring B\ninst✝¹ : Algebra R B\ninst✝ : IsLocalization.Away x B\na : R\nb : B\nm d : ℤ\n⊢ selfZPow x B m * mk' B a 1 = selfZPow x B d * b → selfZPow x B m * mk' B a 1 * selfZPow x B (-d) = b",
"usedConstants": [
... | · intro h
have := congr_arg (fun s : B => s * selfZPow x B (-d)) h
simp only at this
rwa [mul_comm _ b, mul_assoc b _ _, selfZPow_mul_neg, mul_one] at this | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.Localization.BaseChange | {
"line": 107,
"column": 30
} | {
"line": 107,
"column": 41
} | [
{
"pp": "R : Type u_1\ninst✝¹¹ : CommSemiring R\nS : Submonoid R\nA : Type u_2\ninst✝¹⁰ : CommSemiring A\ninst✝⁹ : Algebra R A\ninst✝⁸ : IsLocalization S A\nM₁ : Type u_5\nM₂ : Type u_6\ninst✝⁷ : AddCommMonoid M₁\ninst✝⁶ : AddCommMonoid M₂\ninst✝⁵ : Module R M₁\ninst✝⁴ : Module R M₂\ninst✝³ : Module A M₁\ninst✝... | smul_tmul', | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.RingTheory.Localization.BaseChange | {
"line": 329,
"column": 23
} | {
"line": 329,
"column": 46
} | [
{
"pp": "R : Type u_10\ninst✝² : CommRing R\nM : Submonoid R\nS : Type u_12\ninst✝¹ : CommRing S\ninst✝ : Algebra R S\nRₘ : Type u_10 := Localization M\nSₘ : Type u_12 := Localization (Algebra.algebraMapSubmonoid S M)\nx : R\ny : ↥M\nthis : Algebra Rₘ (S ⊗[R] Rₘ) := Algebra.TensorProduct.rightAlgebra\nh1 : 1 ⊗ₜ... | IsLocalization.mk'_spec | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Module.LocalizedModule.Basic | {
"line": 225,
"column": 6
} | {
"line": 225,
"column": 61
} | [
{
"pp": "case mk\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\nA : Type u_2\ninst✝¹ : Semiring A\ninst✝ : Algebra R A\nS : Submonoid R\na✝ : LocalizedMo... | exact mk_eq.mpr ⟨1, by simp only [zero_mul, smul_zero]⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Category.Ring.Constructions | {
"line": 87,
"column": 4
} | {
"line": 88,
"column": 70
} | [
{
"pp": "case property.left\nR A B : Type u\ninst✝⁴ : CommRing R\ninst✝³ : CommRing A\ninst✝² : CommRing B\ninst✝¹ : Algebra R A\ninst✝ : Algebra R B\ns : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B))\nthis✝ : Algebra R ↑s.pt := ⋯\nf' : A →ₐ[R] ↑s.pt := ⋯\ng' : B →ₐ[R] ↑s.pt := ⋯\nthis : Algeb... | · ext x
exact Algebra.TensorProduct.productMap_left_apply (A := A) _ _ x | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Category.Ring.Constructions | {
"line": 141,
"column": 2
} | {
"line": 143,
"column": 83
} | [
{
"pp": "R S : Type u\ninst✝¹⁰ : CommRing R\ninst✝⁹ : CommRing S\ninst✝⁸ : Algebra R S\nR' S' : Type u\ninst✝⁷ : CommRing R'\ninst✝⁶ : CommRing S'\ninst✝⁵ : Algebra R R'\ninst✝⁴ : Algebra S S'\ninst✝³ : Algebra R' S'\ninst✝² : Algebra R S'\ninst✝¹ : IsScalarTower R R' S'\ninst✝ : IsScalarTower R S S'\nh : IsPus... | have h2 (r : R') : (CommRingCat.isPushout_tensorProduct R R' S).isoPushout.hom
(r ⊗ₜ 1) = (pushout.inl (ofHom _) (ofHom _)) r :=
congr($((CommRingCat.isPushout_tensorProduct R R' S).inl_isoPushout_hom).hom r) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Category.Ring.Constructions | {
"line": 173,
"column": 2
} | {
"line": 173,
"column": 27
} | [
{
"pp": "R A B X : CommRingCat\nf : R ⟶ A\ng : R ⟶ B\na : A ⟶ X\nb : B ⟶ X\nH : IsPushout f g a b\n⊢ Subring.closure (Set.range ⇑(ConcreteCategory.hom a) ∪ Set.range ⇑(ConcreteCategory.hom b)) = ⊤",
"usedConstants": [
"CommRingCat.Hom.hom",
"CommRingCat.carrier",
"CommSemiring.toSemiring",... | algebraize [f.hom, g.hom] | Mathlib.Tactic._aux_Mathlib_Tactic_Algebraize___elabRules_Mathlib_Tactic_tacticAlgebraize___1 | Mathlib.Tactic.tacticAlgebraize__ |
Mathlib.Algebra.Category.Ring.Constructions | {
"line": 174,
"column": 2
} | {
"line": 174,
"column": 89
} | [
{
"pp": "R A B X : CommRingCat\nf : R ⟶ A\ng : R ⟶ B\na : A ⟶ X\nb : B ⟶ X\nH : IsPushout f g a b\nalgInst✝¹ : Algebra ↑R ↑A := (Hom.hom f).toAlgebra\nalgInst✝ : Algebra ↑R ↑B := (Hom.hom g).toAlgebra\n⊢ Subring.closure (Set.range ⇑(ConcreteCategory.hom a) ∪ Set.range ⇑(ConcreteCategory.hom b)) = ⊤",
"usedC... | let e := ((isPushout_tensorProduct R A B).isoIsPushout A B H).commRingCatIsoToRingEquiv | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.CategoryTheory.Comma.Over.Pullback | {
"line": 197,
"column": 7
} | {
"line": 197,
"column": 36
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nX✝ Y✝ : C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nX Y : C\nf : X ⟶ Y\ninst✝ : HasPushoutsAlong f\nx x' : Under X\nu : x ⟶ x'\n⊢ x.hom ≫ Hom.right u ≫ pushout.inl x'.hom f = f ≫ pushout.inr x'.hom f",
"usedConstants": [
"CategoryTheory.CategoryStruct... | by simp [← pushout.condition] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.MorphismProperty.Composition | {
"line": 125,
"column": 4
} | {
"line": 126,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nW : Set (MorphismProperty C)\nh : ∀ W' ∈ W, W'.IsStableUnderComposition\nX✝ Y✝ Z✝ : C\nf : X✝ ⟶ Y✝\ng : Y✝ ⟶ Z✝\nhf : InfSet.sInf W f\nhg : InfSet.sInf W g\n⊢ InfSet.sInf W (f ≫ g)",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.MorphismProperty",
... | rw [sInf_iff] at hf hg ⊢
exact fun W' hW' ↦ (h W' hW').comp_mem _ _ (hf _ hW') (hg _ hW') | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.MorphismProperty.Composition | {
"line": 125,
"column": 4
} | {
"line": 126,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nW : Set (MorphismProperty C)\nh : ∀ W' ∈ W, W'.IsStableUnderComposition\nX✝ Y✝ Z✝ : C\nf : X✝ ⟶ Y✝\ng : Y✝ ⟶ Z✝\nhf : InfSet.sInf W f\nhg : InfSet.sInf W g\n⊢ InfSet.sInf W (f ≫ g)",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.MorphismProperty",
... | rw [sInf_iff] at hf hg ⊢
exact fun W' hW' ↦ (h W' hW').comp_mem _ _ (hf _ hW') (hg _ hW') | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {
"line": 299,
"column": 31
} | {
"line": 299,
"column": 66
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nF✝ : B ⥤ᵖ C\nF : B ⥤ᵒᵖᴸ C\nF' : F.PseudoCore\na✝ b✝ c✝ : B\nf : a✝ ⟶ b✝\ng h : b✝ ⟶ c✝\nη : g ⟶ h\n⊢ F.map₂ (f ◁ η) = F.mapComp f g ≫ F.map f ◁ F.map₂ η ≫ (F'.mapCompIso f h).inv",
"usedConsta... | ← F.mapComp_naturality_right_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Finiteness.Ideal | {
"line": 93,
"column": 2
} | {
"line": 93,
"column": 55
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝³ : Semiring R\ninst✝² : AddCommMonoid M\ninst✝¹ : Module R M\ns : Finset R\ninst✝ : (span ↑s).IsTwoSided\nt : Finset M\n⊢ (span ↑s • Submodule.span R ↑t).FG",
"usedConstants": [
"Eq.mpr",
"Submodule",
"instHSMul",
"Semiring.toModule",
... | classical rw [Submodule.span_smul_span, ← s.coe_smul] | Lean.Elab.Tactic.evalClassical | Lean.Parser.Tactic.classical |
Mathlib.CategoryTheory.IsConnected | {
"line": 130,
"column": 2
} | {
"line": 131,
"column": 57
} | [
{
"pp": "J : Type u₁\ninst✝³ : Category.{v₁, u₁} J\nK : Type u₂\ninst✝² : Category.{v₂, u₂} K\ninst✝¹ : IsPreconnected J\ninst✝ : IsPreconnected K\na : Type (max u₁ u₂)\nF : J × K ⥤ Discrete a\nx✝¹ x✝ : J × K\nj : J\nk : K\nj' : J\nk' : K\n⊢ F.obj (j, k) = F.obj (j', k')",
"usedConstants": [
"Category... | exact (any_functor_const_on_obj (Prod.sectL J k ⋙ F) j j').trans
(any_functor_const_on_obj (Prod.sectR j' K ⋙ F) k k') | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.IsConnected | {
"line": 404,
"column": 11
} | {
"line": 404,
"column": 13
} | [
{
"pp": "J : Type u₁\ninst✝¹ : Category.{v₁, u₁} J\ninst✝ : IsPreconnected J\nr : J → J → Prop\nhr : _root_.Equivalence r\nh : ∀ {j₁ j₂ : J} (x : j₁ ⟶ j₂), r j₁ j₂\nj₁ : J\n⊢ ∀ (j₂ : J), r j₁ j₂",
"usedConstants": []
}
] | j₂ | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.CategoryTheory.IsConnected | {
"line": 445,
"column": 11
} | {
"line": 445,
"column": 13
} | [
{
"pp": "case h\nJ : Type u₁\ninst✝ : Category.{v₁, u₁} J\nh : ∀ (j₁ j₂ : J), ∃ l, List.IsChain Zag (j₁ :: l) ∧ (j₁ :: l).getLast ⋯ = j₂\nj₁ : J\n⊢ ∀ (j₂ : J), Zigzag j₁ j₂",
"usedConstants": []
}
] | j₂ | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.CategoryTheory.Limits.Final | {
"line": 261,
"column": 13
} | {
"line": 261,
"column": 15
} | [
{
"pp": "case h₁\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\nF : C ⥤ D\ninst✝¹ : F.Final\nE : Type u₃\ninst✝ : Category.{v₃, u₃} E\nG : D ⥤ E\ns : Cocone (F ⋙ G)\nj j₁ : C\n⊢ ∀ (X₂ : C) (k₁ : F.obj j ⟶ F.obj j₁) (k₂ : F.obj j ⟶ F.obj X₂) (f : j₁ ⟶ X₂),\n k₁ ≫ F.map ... | j₂ | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.CategoryTheory.Limits.Final | {
"line": 265,
"column": 13
} | {
"line": 265,
"column": 15
} | [
{
"pp": "case h₂\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\nF : C ⥤ D\ninst✝¹ : F.Final\nE : Type u₃\ninst✝ : Category.{v₃, u₃} E\nG : D ⥤ E\ns : Cocone (F ⋙ G)\nj j₁ : C\n⊢ ∀ (X₂ : C) (k₁ : F.obj j ⟶ F.obj j₁) (k₂ : F.obj j ⟶ F.obj X₂) (f : j₁ ⟶ X₂),\n k₁ ≫ F.map ... | j₂ | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.CategoryTheory.Limits.Final | {
"line": 560,
"column": 13
} | {
"line": 560,
"column": 15
} | [
{
"pp": "C : 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\nd : D\nZ : (X : C) → (F.obj X ⟶ d) → Sort u_1\nh₁ : (X₁ X₂ : C) → (k₁ : F.obj X₁ ⟶ d) → (k₂ : F.obj X₂ ⟶ d) → (f : X₁ ⟶ X₂) → F.map f... | j₂ | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.CategoryTheory.Limits.Final | {
"line": 564,
"column": 13
} | {
"line": 564,
"column": 15
} | [
{
"pp": "C : 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\nd : D\nZ : (X : C) → (F.obj X ⟶ d) → Sort u_1\nh₁ : (X₁ X₂ : C) → (k₁ : F.obj X₁ ⟶ d) → (k₂ : F.obj X₂ ⟶ d) → (f : X₁ ⟶ X₂) → F.map f... | j₂ | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.CategoryTheory.Limits.Final | {
"line": 616,
"column": 13
} | {
"line": 616,
"column": 15
} | [
{
"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 j₁ : C\n⊢ ∀ (X₂ : C) (k₁ : F.obj j₁ ⟶ F.obj j) (k₂ : F.obj X₂ ⟶ F.obj j) (f : j₁ ⟶ X₂),\n F.map f ≫ k... | j₂ | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.CategoryTheory.Limits.Final | {
"line": 620,
"column": 13
} | {
"line": 620,
"column": 15
} | [
{
"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 j₁ : C\n⊢ ∀ (X₂ : C) (k₁ : F.obj j₁ ⟶ F.obj j) (k₂ : F.obj X₂ ⟶ F.obj j) (f : j₁ ⟶ X₂),\n F.map f ≫ k... | j₂ | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.CategoryTheory.Limits.Final | {
"line": 672,
"column": 21
} | {
"line": 675,
"column": 66
} | [
{
"pp": "C : 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\nB : Type u₄\ninst✝¹ : Category.{v₄, u₄} B\nH : E ⥤ B\ninst✝ : ReflectsLimit G H\nc : Cone (F ⋙ G)\nhc : IsLimit (H.mapCone c)\n⊢ Non... | by
refine ⟨isLimitExtendConeEquiv F _ (isLimitOfReflects H ?_)⟩
let hc' := (isLimitExtendConeEquiv (G := G ⋙ H) F _).symm hc
exact IsLimit.ofIsoLimit hc' (Cone.ext (Iso.refl _) (by simp)) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | {
"line": 333,
"column": 30
} | {
"line": 333,
"column": 42
} | [
{
"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\nh : IsLimit (Fork.ofι f.op ⋯)\n⊢ (pushout.inl f.op f.op).unop ≫ f.op.unop = (pushout.inr f.op f.op).unop ≫ f.op.unop",
"usedConstants": [
"Eq.mpr",
"Opposit... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | {
"line": 333,
"column": 43
} | {
"line": 333,
"column": 55
} | [
{
"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\nh : IsLimit (Fork.ofι f.op ⋯)\n⊢ (f.op ≫ pushout.inl f.op f.op).unop = (pushout.inr f.op f.op).unop ≫ f.op.unop",
"usedConstants": [
"Eq.mpr",
"Opposite",
... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | {
"line": 333,
"column": 26
} | {
"line": 333,
"column": 74
} | [
{
"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\nh : IsLimit (Fork.ofι f.op ⋯)\n⊢ (pushout.inl f.op f.op).unop ≫ f.op.unop = (pushout.inr f.op f.op).unop ≫ f.op.unop",
"usedConstants": [
"Eq.mpr",
"Opposit... | rw [← unop_comp, ← unop_comp, pushout.condition] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | {
"line": 333,
"column": 26
} | {
"line": 333,
"column": 74
} | [
{
"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\nh : IsLimit (Fork.ofι f.op ⋯)\n⊢ (pushout.inl f.op f.op).unop ≫ f.op.unop = (pushout.inr f.op f.op).unop ≫ f.op.unop",
"usedConstants": [
"Eq.mpr",
"Opposit... | rw [← unop_comp, ← unop_comp, pushout.condition] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | {
"line": 333,
"column": 26
} | {
"line": 333,
"column": 74
} | [
{
"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\nh : IsLimit (Fork.ofι f.op ⋯)\n⊢ (pushout.inl f.op f.op).unop ≫ f.op.unop = (pushout.inr f.op f.op).unop ≫ f.op.unop",
"usedConstants": [
"Eq.mpr",
"Opposit... | rw [← unop_comp, ← unop_comp, pushout.condition] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | {
"line": 371,
"column": 79
} | {
"line": 371,
"column": 91
} | [
{
"pp": "case refine_1\nC : Type u₁\ninst✝² : Category.{v₁, u₁} C\nJ : Type u₂\ninst✝¹ : Category.{v₂, u₂} J\nX Y : C\nf : X ⟶ Y\ninst✝ : HasPushout f f\nh : IsColimit (Cofork.ofπ f.op ⋯)\n⊢ (Iso.refl (Opposite.unop (Opposite.op Y))).hom ≫ pushout.inl f f =\n (pullback.fst f.op f.op).unop ≫ (pushoutIsoUnopPu... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | {
"line": 373,
"column": 79
} | {
"line": 373,
"column": 91
} | [
{
"pp": "case refine_2\nC : Type u₁\ninst✝² : Category.{v₁, u₁} C\nJ : Type u₂\ninst✝¹ : Category.{v₂, u₂} J\nX Y : C\nf : X ⟶ Y\ninst✝ : HasPushout f f\nh : IsColimit (Cofork.ofπ f.op ⋯)\n⊢ (Iso.refl (Opposite.unop (Opposite.op Y))).hom ≫ pushout.inr f f =\n (pullback.snd f.op f.op).unop ≫ (pushoutIsoUnopPu... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.MorphismProperty.Limits | {
"line": 58,
"column": 40
} | {
"line": 60,
"column": 46
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nP : MorphismProperty C\n⊢ P ≤ P.pullbacks",
"usedConstants": [
"CategoryTheory.IsPullback.of_id_fst",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.MorphismProperty.pul... | by
intro A B q hq
exact P.pullbacks_mk IsPullback.of_id_fst hq | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Diagonal | {
"line": 96,
"column": 2
} | {
"line": 97,
"column": 68
} | [
{
"pp": "C : Type u_1\ninst✝¹ : Category.{v_1, u_1} C\nX Y : C\ninst✝ : HasPullbacks C\nU V₁ V₂ : C\nf : X ⟶ Y\ni : U ⟶ Y\ni₁ : V₁ ⟶ pullback f i\ni₂ : V₂ ⟶ pullback f i\n⊢ snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫\n fst (i₁ ≫ snd f i) (i₂ ≫ snd f i) ≫ i... | conv_rhs => rw [← Category.comp_id (pullback.fst _ _)]
rw [← diagonal_fst f, pullback.condition_assoc, pullback.lift_fst] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Diagonal | {
"line": 96,
"column": 2
} | {
"line": 97,
"column": 68
} | [
{
"pp": "C : Type u_1\ninst✝¹ : Category.{v_1, u_1} C\nX Y : C\ninst✝ : HasPullbacks C\nU V₁ V₂ : C\nf : X ⟶ Y\ni : U ⟶ Y\ni₁ : V₁ ⟶ pullback f i\ni₂ : V₂ ⟶ pullback f i\n⊢ snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫\n fst (i₁ ≫ snd f i) (i₂ ≫ snd f i) ≫ i... | conv_rhs => rw [← Category.comp_id (pullback.fst _ _)]
rw [← diagonal_fst f, pullback.condition_assoc, pullback.lift_fst] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.RingHomProperties | {
"line": 148,
"column": 4
} | {
"line": 148,
"column": 81
} | [
{
"pp": "P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop\nh₁ : RespectsIso P\nh₂ :\n ∀ ⦃R S T : Type u⦄ [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T] [inst_3 : Algebra R S]\n [inst_4 : Algebra R T], P (algebraMap R T) → P (algebraMap S (S ⊗[R] T))\nR S R... | suffices e.toLinearMap.restrictScalars R = f'.toLinearMap from congr($this x) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSuffices__1 | Lean.Parser.Tactic.tacticSuffices_ |
Mathlib.RingTheory.RingHomProperties | {
"line": 199,
"column": 2
} | {
"line": 201,
"column": 53
} | [
{
"pp": "case refine_3\nP : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop\nh : (toMorphismProperty fun {R S} [CommRing R] [CommRing S] ↦ P).RespectsIso\n⊢ ∀ {R S T : Type u} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T] (f : R →+* S) (e : S ≃+* T),\n (fun {... | · intro X Y Z _ _ _ f e hf
exact MorphismProperty.RespectsIso.postcomp (toMorphismProperty P)
e.toCommRingCatIso.hom (CommRingCat.ofHom f) hf | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.CategoryTheory.Limits.Shapes.Diagonal | {
"line": 313,
"column": 96
} | {
"line": 318,
"column": 28
} | [
{
"pp": "C : Type u_1\ninst✝⁵ : Category.{v_1, u_1} C\nX Y : C\ninst✝⁴ : HasPullbacks C\nS T : C\nf : X ⟶ T\ng : Y ⟶ T\ni : T ⟶ S\ninst✝³ : HasPullback i i\ninst✝² : HasPullback f g\ninst✝¹ : HasPullback (f ≫ i) (g ≫ i)\ninst✝ : HasPullback (diagonal i) (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) ⋯ ⋯)\n⊢ IsPullback (fs... | by
apply IsPullback.of_iso_pullback _ (pullbackDiagonalMapIdIso f g i).symm
· simp
· ext <;> simp
· constructor
ext <;> simp [condition] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.ObjectProperty.Small | {
"line": 50,
"column": 2
} | {
"line": 50,
"column": 50
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nD : Type u'\ninst✝¹ : Category.{v', u'} D\nP : ObjectProperty Cᵒᵖ\ninst✝ : ObjectProperty.Small.{w, v, u} P\n⊢ ObjectProperty.Small.{w, v, u} P.unop",
"usedConstants": [
"Eq.mpr",
"small_congr",
"Opposite",
"CategoryTheory.ObjectProper... | simpa only [← small_congr P.unop.subtypeOpEquiv] | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.CategoryTheory.ObjectProperty.Small | {
"line": 50,
"column": 2
} | {
"line": 50,
"column": 50
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nD : Type u'\ninst✝¹ : Category.{v', u'} D\nP : ObjectProperty Cᵒᵖ\ninst✝ : ObjectProperty.Small.{w, v, u} P\n⊢ ObjectProperty.Small.{w, v, u} P.unop",
"usedConstants": [
"Eq.mpr",
"small_congr",
"Opposite",
"CategoryTheory.ObjectProper... | simpa only [← small_congr P.unop.subtypeOpEquiv] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.ObjectProperty.Small | {
"line": 50,
"column": 2
} | {
"line": 50,
"column": 50
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nD : Type u'\ninst✝¹ : Category.{v', u'} D\nP : ObjectProperty Cᵒᵖ\ninst✝ : ObjectProperty.Small.{w, v, u} P\n⊢ ObjectProperty.Small.{w, v, u} P.unop",
"usedConstants": [
"Eq.mpr",
"small_congr",
"Opposite",
"CategoryTheory.ObjectProper... | simpa only [← small_congr P.unop.subtypeOpEquiv] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.MorphismProperty.Limits | {
"line": 852,
"column": 2
} | {
"line": 852,
"column": 80
} | [
{
"pp": "case refine_1\nC : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasPullbacks C\nP : MorphismProperty C\ninst✝² : P.IsStableUnderBaseChange\ninst✝¹ : P.IsMultiplicative\nQ : MorphismProperty C\ninst✝ : Q.IsStableUnderBaseChange\nhP : P.HasOfPostcompProperty Q\nX Y : C\nf : X ⟶ Y\nhf : Q f\n⊢ P.diagonal ... | · exact hP.of_postcomp _ _ (Q.pullback_fst _ _ hf) (by simpa using P.id_mem X) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape | {
"line": 249,
"column": 41
} | {
"line": 250,
"column": 69
} | [
{
"pp": "C : Type u_1\ninst✝² : Category.{v_1, u_1} C\nP : ObjectProperty C\nJ : Type u'\ninst✝¹ : Category.{v', u'} J\nJ' : Type u''\ninst✝ : Category.{v'', u''} J'\ne : J ≌ J'\n⊢ P.IsClosedUnderLimitsOfShape J ↔ P.IsClosedUnderLimitsOfShape J'",
"usedConstants": [
"congrArg",
"Prop.le",
... | by
simp only [isClosedUnderLimitsOfShape_iff, P.limitsOfShape_congr e] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Category.ModuleCat.EpiMono | {
"line": 71,
"column": 6
} | {
"line": 72,
"column": 14
} | [
{
"pp": "R : Type u\ninst✝² : Ring R\nX Y : ModuleCat R\nf✝ : X ⟶ Y\nM : Type v\ninst✝¹ : AddCommGroup M\ninst✝ : Module R M\nX✝ Y✝ : ModuleCat R\nf : X✝ ⟶ Y✝\nhf : Mono f\n⊢ Mono ((forget (ModuleCat R)).map f)",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Mono",
"ModuleCat",
"congr... | rw [CategoryTheory.ofHom_mono_iff_injective, ← mono_iff_injective]
exact hf | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Category.ModuleCat.EpiMono | {
"line": 71,
"column": 6
} | {
"line": 72,
"column": 14
} | [
{
"pp": "R : Type u\ninst✝² : Ring R\nX Y : ModuleCat R\nf✝ : X ⟶ Y\nM : Type v\ninst✝¹ : AddCommGroup M\ninst✝ : Module R M\nX✝ Y✝ : ModuleCat R\nf : X✝ ⟶ Y✝\nhf : Mono f\n⊢ Mono ((forget (ModuleCat R)).map f)",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Mono",
"ModuleCat",
"congr... | rw [CategoryTheory.ofHom_mono_iff_injective, ← mono_iff_injective]
exact hf | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Constructions.Equalizers | {
"line": 159,
"column": 8
} | {
"line": 159,
"column": 50
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\nD : Type u'\ninst✝² : Category.{v', u'} D\nG : C ⥤ D\ninst✝¹ : HasBinaryCoproducts C\ninst✝ : HasPushouts C\nF : WalkingParallelPair ⥤ C\n⊢ F.map WalkingParallelPairHom.left ≫ pushoutInl F = F.map WalkingParallelPairHom.right ≫ pushoutInl F",
"usedConstants":... | conv_rhs => rw [pushoutInl_eq_pushout_inr] | Mathlib.Tactic.Conv._aux_Mathlib_Tactic_Conv___macroRules_Mathlib_Tactic_Conv_convRHS_1 | Mathlib.Tactic.Conv.convRHS |
Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {
"line": 374,
"column": 55
} | {
"line": 374,
"column": 72
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : CartesianMonoidalCategory C\nX : C\n⊢ (λ_ X).hom = snd (𝟙_ C) X",
"usedConstants": [
"CategoryTheory.Limits.IsTerminal.from",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalCa... | by simp [snd_def] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {
"line": 383,
"column": 34
} | {
"line": 383,
"column": 51
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : CartesianMonoidalCategory C\nX : C\n⊢ (λ_ X).inv ≫ snd (𝟙_ C) X = 𝟙 X",
"usedConstants": [
"CategoryTheory.Limits.IsTerminal.from",
"CategoryTheory.Iso.inv_hom_id",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
... | by simp [snd_def] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {
"line": 689,
"column": 2
} | {
"line": 690,
"column": 53
} | [
{
"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 ... | letI : ∀ X, IsIso ((prodComparisonBifunctorNatTrans F).app X) :=
fun _ ↦ by dsimp; apply NatIso.isIso_of_isIso_app | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLetI___1 | Lean.Parser.Tactic.tacticLetI__ |
Mathlib.CategoryTheory.Abelian.NonPreadditive | {
"line": 337,
"column": 2
} | {
"line": 341,
"column": 65
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : NonPreadditiveAbelian C\nX Y : C\na : X ⟶ Y\n⊢ a - 0 = a",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"HSub.hSub",
"Catego... | rw [sub_def]
conv_lhs =>
congr; congr; rw [← Category.comp_id a]
case a.g => rw [show 0 = a ≫ (0 : Y ⟶ Y) by simp]
rw [← prod.comp_lift, Category.assoc, lift_σ, Category.comp_id] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Abelian.NonPreadditive | {
"line": 337,
"column": 2
} | {
"line": 341,
"column": 65
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : NonPreadditiveAbelian C\nX Y : C\na : X ⟶ Y\n⊢ a - 0 = a",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"HSub.hSub",
"Catego... | rw [sub_def]
conv_lhs =>
congr; congr; rw [← Category.comp_id a]
case a.g => rw [show 0 = a ≫ (0 : Y ⟶ Y) by simp]
rw [← prod.comp_lift, Category.assoc, lift_σ, Category.comp_id] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | {
"line": 451,
"column": 6
} | {
"line": 454,
"column": 11
} | [
{
"pp": "C : Type u\ninst✝⁸ : Category.{v, u} C\nJ : Type w\ninst✝⁷ : SmallCategory J\nD : Type u₂\ninst✝⁶ : Category.{v₂, u₂} D\ninst✝⁵ : HasColimitsOfShape (Discrete J) C\ninst✝⁴ : HasColimitsOfShape (Discrete ((p : J × J) × (p.1 ⟶ p.2))) C\ninst✝³ : HasCoequalizers C\nG : C ⥤ D\ninst✝² : PreservesColimitsOfS... | intro f
dsimp [P, Q, t, Cofan.mk]
simp only [← G.map_comp, colimit.ι_desc]
dsimp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | {
"line": 451,
"column": 6
} | {
"line": 454,
"column": 11
} | [
{
"pp": "C : Type u\ninst✝⁸ : Category.{v, u} C\nJ : Type w\ninst✝⁷ : SmallCategory J\nD : Type u₂\ninst✝⁶ : Category.{v₂, u₂} D\ninst✝⁵ : HasColimitsOfShape (Discrete J) C\ninst✝⁴ : HasColimitsOfShape (Discrete ((p : J × J) × (p.1 ⟶ p.2))) C\ninst✝³ : HasCoequalizers C\nG : C ⥤ D\ninst✝² : PreservesColimitsOfS... | intro f
dsimp [P, Q, t, Cofan.mk]
simp only [← G.map_comp, colimit.ι_desc]
dsimp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Abelian.Basic | {
"line": 756,
"column": 59
} | {
"line": 756,
"column": 74
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\ninst✝² : Abelian C\ninst✝¹ : HasPushouts C\nW X Y Z : C\nf : X ⟶ Y\ng : X ⟶ Z\ninst✝ : Mono f\nR : C\ne : R ⟶ Z\nh : e ≫ pushout.inr f g = 0\nu : R ⟶ Y ⊞ Z := biprod.lift 0 e\nhu : u ≫ BiproductToPushoutIsCokernel.biproductToPushout f g = 0\nthis✝¹ : IsLimit (Ker... | biprod.lift_snd | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Abelian.Basic | {
"line": 774,
"column": 63
} | {
"line": 774,
"column": 78
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\ninst✝² : Abelian C\ninst✝¹ : HasPushouts C\nW X Y Z : C\nf : X ⟶ Y\ng : X ⟶ Z\ninst✝ : Mono g\nR : C\ne : R ⟶ Y\nh : e ≫ pushout.inl f g = 0\nu : R ⟶ Y ⊞ Z := biprod.lift e 0\nhu : u ≫ BiproductToPushoutIsCokernel.biproductToPushout f g = 0\nthis : IsLimit (Kerne... | biprod.lift_snd | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Basic | {
"line": 124,
"column": 32
} | {
"line": 124,
"column": 55
} | [
{
"pp": "X : Type u_2\nt₁ t₂ : TopologicalSpace X\n⊢ (∀ (s : Set X), IsOpen[t₁] s ↔ IsOpen[t₂] s) ↔ ∀ (s : Set X), IsClosed[t₁] s ↔ IsClosed[t₂] s",
"usedConstants": [
"Eq.mpr",
"Function.Surjective.forall",
"congrArg",
"Compl.compl",
"BooleanAlgebra.toCompl",
"id",
... | compl_surjective.forall | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Closure | {
"line": 579,
"column": 2
} | {
"line": 579,
"column": 74
} | [
{
"pp": "X : Type u\ninst✝ : TopologicalSpace X\ns : Set X\n⊢ frontier s = (interior s)ᶜ ∩ (interior sᶜ)ᶜ",
"usedConstants": [
"Eq.mpr",
"frontier_compl",
"frontier",
"congrArg",
"Compl.compl",
"id",
"Set.diff_eq",
"Set.instInter",
"Set.instCompl",
... | rw [← frontier_compl, ← closure_compl, ← diff_eq, closure_diff_interior] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.Closure | {
"line": 579,
"column": 2
} | {
"line": 579,
"column": 74
} | [
{
"pp": "X : Type u\ninst✝ : TopologicalSpace X\ns : Set X\n⊢ frontier s = (interior s)ᶜ ∩ (interior sᶜ)ᶜ",
"usedConstants": [
"Eq.mpr",
"frontier_compl",
"frontier",
"congrArg",
"Compl.compl",
"id",
"Set.diff_eq",
"Set.instInter",
"Set.instCompl",
... | rw [← frontier_compl, ← closure_compl, ← diff_eq, closure_diff_interior] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Closure | {
"line": 579,
"column": 2
} | {
"line": 579,
"column": 74
} | [
{
"pp": "X : Type u\ninst✝ : TopologicalSpace X\ns : Set X\n⊢ frontier s = (interior s)ᶜ ∩ (interior sᶜ)ᶜ",
"usedConstants": [
"Eq.mpr",
"frontier_compl",
"frontier",
"congrArg",
"Compl.compl",
"id",
"Set.diff_eq",
"Set.instInter",
"Set.instCompl",
... | rw [← frontier_compl, ← closure_compl, ← diff_eq, closure_diff_interior] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Order | {
"line": 89,
"column": 4
} | {
"line": 90,
"column": 77
} | [
{
"pp": "case sUnion\nα : Type u\ng : Set (Set α)\na : α\nthis : TopologicalSpace α := generateFrom g\ns : Set α\nS✝ : Set (Set α)\na✝ : ∀ s ∈ S✝, GenerateOpen g s\nhS : ∀ s ∈ S✝, a ∈ s → ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s ≤ 𝓟 s\nha : a ∈ ⋃₀ S✝\n⊢ ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s ≤ 𝓟 (⋃₀ S✝)",
"usedConstants"... | let ⟨t, htS, hat⟩ := ha
exact (hS t htS hat).trans (principal_mono.2 <| subset_sUnion_of_mem htS) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Order | {
"line": 89,
"column": 4
} | {
"line": 90,
"column": 77
} | [
{
"pp": "case sUnion\nα : Type u\ng : Set (Set α)\na : α\nthis : TopologicalSpace α := generateFrom g\ns : Set α\nS✝ : Set (Set α)\na✝ : ∀ s ∈ S✝, GenerateOpen g s\nhS : ∀ s ∈ S✝, a ∈ s → ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s ≤ 𝓟 s\nha : a ∈ ⋃₀ S✝\n⊢ ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s ≤ 𝓟 (⋃₀ S✝)",
"usedConstants"... | let ⟨t, htS, hat⟩ := ha
exact (hS t htS hat).trans (principal_mono.2 <| subset_sUnion_of_mem htS) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Order | {
"line": 935,
"column": 20
} | {
"line": 935,
"column": 37
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nt : TopologicalSpace β\nf : α → β\na : α\n⊢ map f (comap f (𝓝 (f a))) = 𝓝[range f] f a",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Filter.map",
"nhdsWithin",
"Filter.map_comap",
"nhds",
"id",
"Filter.instInf",
"Filt... | Filter.map_comap, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Maps.Basic | {
"line": 487,
"column": 17
} | {
"line": 487,
"column": 40
} | [
{
"pp": "X : Type u_1\nY : Type u_2\nf : X → Y\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\n⊢ (∀ (U : Set X), IsOpen[inst✝¹] U → IsOpen[inst✝] (f '' U)) ↔\n ∀ {u : Set X}, IsClosed[inst✝¹] u → IsClosed[inst✝] (kernImage f u)",
"usedConstants": [
"Eq.mpr",
"Function.Surjective.for... | compl_surjective.forall | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Maps.Basic | {
"line": 509,
"column": 36
} | {
"line": 509,
"column": 59
} | [
{
"pp": "X : Type u_1\nY : Type u_2\nf : X → Y\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\n⊢ (∀ (s : Set X), f '' interior s ⊆ interior (f '' s)) ↔\n ∀ {s : Set X}, closure[inst✝] (kernImage f s) ⊆ kernImage f (closure[inst✝¹] s)",
"usedConstants": [
"Eq.mpr",
"Function.Surjecti... | compl_surjective.forall | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Maps.Basic | {
"line": 577,
"column": 19
} | {
"line": 577,
"column": 42
} | [
{
"pp": "X : Type u_1\nY : Type u_2\nf : X → Y\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\n⊢ (∀ (U : Set X), IsClosed[inst✝¹] U → IsClosed[inst✝] (f '' U)) ↔\n ∀ {u : Set X}, IsOpen[inst✝¹] u → IsOpen[inst✝] (kernImage f u)",
"usedConstants": [
"Eq.mpr",
"Function.Surjective.for... | compl_surjective.forall | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Maps.Basic | {
"line": 597,
"column": 37
} | {
"line": 597,
"column": 60
} | [
{
"pp": "X : Type u_1\nY : Type u_2\nf : X → Y\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\n⊢ (∀ (s : Set X), closure[inst✝] (f '' s) ⊆ f '' closure[inst✝¹] s) ↔\n ∀ {s : Set X}, kernImage f (interior s) ⊆ interior (kernImage f s)",
"usedConstants": [
"Eq.mpr",
"Function.Surjecti... | compl_surjective.forall | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Filter.Finite | {
"line": 147,
"column": 4
} | {
"line": 147,
"column": 33
} | [
{
"pp": "case mpr\nα : Type u\nι : Type u_2\np : ι → Prop\ns : ι → Set α\nt : Set α\nI : Set ι\nhIf : I.Finite\nhpI : ∀ i ∈ I, p i\nhst : ⋂ i ∈ I, s i ⊆ t\n⊢ t ∈ ⨅ i, ⨅ (_ : p i), 𝓟 (s i)",
"usedConstants": [
"congrArg",
"Set.iInter",
"Set.biInter_eq_iInter",
"Membership.mem",
... | rw [biInter_eq_iInter] at hst | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.Filter.Bases.Finite | {
"line": 94,
"column": 2
} | {
"line": 94,
"column": 59
} | [
{
"pp": "α : Type u_1\nI : Type u_7\ninst✝ : Finite I\nl : I → Filter α\nι : I → Sort u_6\np : (i : I) → ι i → Prop\ns : (i : I) → ι i → Set α\nhd : Pairwise (Disjoint on l)\nh : ∀ (i : I), (l i).HasBasis (p i) (s i)\n⊢ ∃ ind, (∀ (i : I), p i (ind i)) ∧ Pairwise (Disjoint on fun i ↦ s i (ind i))",
"usedCons... | rcases hd.exists_mem_filter_of_disjoint with ⟨t, htl, hd⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Order.Filter.Finite | {
"line": 304,
"column": 2
} | {
"line": 306,
"column": 35
} | [
{
"pp": "α : Type u\nl : Filter α\nι : Type u_2\ns : Set ι\nhs : s.Finite\nf g : ι → Set α\nhle : ∀ i ∈ s, f i ≤ᶠ[l] g i\n⊢ ⋃ i ∈ s, f i ≤ᶠ[l] ⋃ i ∈ s, g i",
"usedConstants": [
"Eq.mpr",
"Filter.EventuallyLE.iUnion",
"congrArg",
"Finite",
"Prop.le",
"Membership.mem",
... | have := hs.to_subtype
rw [biUnion_eq_iUnion, biUnion_eq_iUnion]
exact .iUnion fun i ↦ hle i.1 i.2 | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Filter.Finite | {
"line": 304,
"column": 2
} | {
"line": 306,
"column": 35
} | [
{
"pp": "α : Type u\nl : Filter α\nι : Type u_2\ns : Set ι\nhs : s.Finite\nf g : ι → Set α\nhle : ∀ i ∈ s, f i ≤ᶠ[l] g i\n⊢ ⋃ i ∈ s, f i ≤ᶠ[l] ⋃ i ∈ s, g i",
"usedConstants": [
"Eq.mpr",
"Filter.EventuallyLE.iUnion",
"congrArg",
"Finite",
"Prop.le",
"Membership.mem",
... | have := hs.to_subtype
rw [biUnion_eq_iUnion, biUnion_eq_iUnion]
exact .iUnion fun i ↦ hle i.1 i.2 | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.NhdsWithin | {
"line": 606,
"column": 23
} | {
"line": 606,
"column": 40
} | [
{
"pp": "α : Type u_5\nβ : Type u_6\nt : TopologicalSpace β\nf : α → β\ns : Set α\n⊢ map f (comap f (𝓝ˢ (f '' s))) = 𝓝ˢ[range f] (f '' s)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Filter.map",
"Filter.map_comap",
"id",
"Filter.instInf",
"nhdsSetWithin",
"F... | Filter.map_comap, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.ContinuousOn | {
"line": 327,
"column": 2
} | {
"line": 327,
"column": 74
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : TopologicalSpace α\ninst✝ : TopologicalSpace β\nf : α → β\ns : Set α\nx : α\nh : s ∈ 𝓝 x\n⊢ ContinuousWithinAt f s x ↔ ContinuousAt f x",
"usedConstants": [
"Eq.mpr",
"ContinuousWithinAt",
"congrArg",
"ContinuousAt",
"continuousWit... | rw [← univ_inter s, continuousWithinAt_inter h, continuousWithinAt_univ] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.ContinuousOn | {
"line": 327,
"column": 2
} | {
"line": 327,
"column": 74
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : TopologicalSpace α\ninst✝ : TopologicalSpace β\nf : α → β\ns : Set α\nx : α\nh : s ∈ 𝓝 x\n⊢ ContinuousWithinAt f s x ↔ ContinuousAt f x",
"usedConstants": [
"Eq.mpr",
"ContinuousWithinAt",
"congrArg",
"ContinuousAt",
"continuousWit... | rw [← univ_inter s, continuousWithinAt_inter h, continuousWithinAt_univ] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.ContinuousOn | {
"line": 327,
"column": 2
} | {
"line": 327,
"column": 74
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : TopologicalSpace α\ninst✝ : TopologicalSpace β\nf : α → β\ns : Set α\nx : α\nh : s ∈ 𝓝 x\n⊢ ContinuousWithinAt f s x ↔ ContinuousAt f x",
"usedConstants": [
"Eq.mpr",
"ContinuousWithinAt",
"congrArg",
"ContinuousAt",
"continuousWit... | rw [← univ_inter s, continuousWithinAt_inter h, continuousWithinAt_univ] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Group.MinMax | {
"line": 25,
"column": 2
} | {
"line": 25,
"column": 34
} | [
{
"pp": "α : Type u_1\ninst✝² : Group α\ninst✝¹ : LinearOrder α\ninst✝ : MulLeftMono α\na : α\n⊢ max a 1 / max a⁻¹ 1 = a",
"usedConstants": [
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"le_total",
"O... | rcases le_total a 1 with (h | h) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Algebra.Order.Group.MinMax | {
"line": 40,
"column": 2
} | {
"line": 40,
"column": 20
} | [
{
"pp": "G₀ : Type u_1\ninst✝¹ : Inv G₀\ninst✝ : LinearOrder G₀\nx y : G₀\n⊢ min x⁻¹ y⁻¹ ≤ (max x y)⁻¹",
"usedConstants": [
"le_total"
]
}
] | cases le_total x y | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.