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.MeasureTheory.Integral.IntervalIntegral.ContDiff | {
"line": 68,
"column": 4
} | {
"line": 70,
"column": 8
} | [
{
"pp": "case inr\nE : Type u_3\ninst✝² : NormedAddCommGroup E\ninst✝¹ : NormedSpace ℝ E\nf : ℝ → E\na b : ℝ\ninst✝ : CompleteSpace E\nh : ContDiffOn ℝ 1 f [[a, b]]\nhab : b < a\n⊢ ∫ (x : ℝ) in a..b, deriv f x = f b - f a",
"usedConstants": [
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"N... | simp only [uIcc_of_ge hab.le] at h
rw [integral_symm, integral_deriv_of_contDiffOn_Icc h hab.le]
abel | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | {
"line": 183,
"column": 2
} | {
"line": 207,
"column": 25
} | [
{
"pp": "r : ℝ\nhr : 0 < r\ns : ℂ\nhs : ‖s‖ < r\nl : ℂ\nh : 2 * r ≤ ‖l‖\n⊢ ‖1 / (s - l) ^ 2 - 1 / l ^ 2‖ ≤ 10 * r * ‖l‖ ^ (-3)",
"usedConstants": [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"NormedCommRing.toNormedRing",
"AddGroup.toSubtractionMonoid",
"Real.instIsOrderedRing",
... | have : s ≠ ↑l := by rintro rfl; linarith
have : 0 < ‖l‖ := by linarith
calc
_ = ‖(↑l ^ 2 - (s - ↑l) ^ 2) / ((s - ↑l) ^ 2 * ↑l ^ 2)‖ := by
rw [div_sub_div, one_mul, mul_one]
· simpa [sub_eq_zero]
· simpa
_ = ‖l ^ 2 - (s - l) ^ 2‖ / (‖s - l‖ ^ 2 * ‖l‖ ^ 2) := by simp
_ ≤ ‖l ^ 2 - (s - l)... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | {
"line": 183,
"column": 2
} | {
"line": 207,
"column": 25
} | [
{
"pp": "r : ℝ\nhr : 0 < r\ns : ℂ\nhs : ‖s‖ < r\nl : ℂ\nh : 2 * r ≤ ‖l‖\n⊢ ‖1 / (s - l) ^ 2 - 1 / l ^ 2‖ ≤ 10 * r * ‖l‖ ^ (-3)",
"usedConstants": [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"NormedCommRing.toNormedRing",
"AddGroup.toSubtractionMonoid",
"Real.instIsOrderedRing",
... | have : s ≠ ↑l := by rintro rfl; linarith
have : 0 < ‖l‖ := by linarith
calc
_ = ‖(↑l ^ 2 - (s - ↑l) ^ 2) / ((s - ↑l) ^ 2 * ↑l ^ 2)‖ := by
rw [div_sub_div, one_mul, mul_one]
· simpa [sub_eq_zero]
· simpa
_ = ‖l ^ 2 - (s - l) ^ 2‖ / (‖s - l‖ ^ 2 * ‖l‖ ^ 2) := by simp
_ ≤ ‖l ^ 2 - (s - l)... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.ChebyshevGauss | {
"line": 42,
"column": 2
} | {
"line": 42,
"column": 15
} | [
{
"pp": "n : ℕ\nk : ℤ\nhn : n ≠ 0\nhk : ¬2 * ↑n ∣ k\n⊢ Complex.exp (↑k / ↑n * ↑π * I) ≠ 1",
"usedConstants": [
"Int.cast",
"Dvd.dvd",
"instHDiv",
"Real.pi",
"HMul.hMul",
"Mathlib.Tactic.Contrapose.contrapose₄",
"Complex.instDivInvMonoid",
"Complex.instMul",
... | contrapose hk | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose_1 | Mathlib.Tactic.Contrapose.contrapose |
Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | {
"line": 290,
"column": 2
} | {
"line": 292,
"column": 69
} | [
{
"pp": "L : PeriodPair\n⊢ HasSumLocallyUniformly (fun l z ↦ 1 / (z - ↑l) ^ 2 - 1 / ↑l ^ 2) ℘[L]",
"usedConstants": [
"UniformSpace",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"Submodule",
"PeriodPair.ω₁_div_two_notMem_lattice",
"instHDiv",
"NonUnitalCommRing... | convert! L.hasSumLocallyUniformly_weierstrassPExcept (L.ω₁ / 2) using 3 with l
· rw [if_neg]; exact fun e ↦ L.ω₁_div_two_notMem_lattice (e ▸ l.2)
· rw [L.weierstrassPExcept_of_notMem _ L.ω₁_div_two_notMem_lattice] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | {
"line": 290,
"column": 2
} | {
"line": 292,
"column": 69
} | [
{
"pp": "L : PeriodPair\n⊢ HasSumLocallyUniformly (fun l z ↦ 1 / (z - ↑l) ^ 2 - 1 / ↑l ^ 2) ℘[L]",
"usedConstants": [
"UniformSpace",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"Submodule",
"PeriodPair.ω₁_div_two_notMem_lattice",
"instHDiv",
"NonUnitalCommRing... | convert! L.hasSumLocallyUniformly_weierstrassPExcept (L.ω₁ / 2) using 3 with l
· rw [if_neg]; exact fun e ↦ L.ω₁_div_two_notMem_lattice (e ▸ l.2)
· rw [L.weierstrassPExcept_of_notMem _ L.ω₁_div_two_notMem_lattice] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | {
"line": 370,
"column": 2
} | {
"line": 370,
"column": 55
} | [
{
"pp": "case neg\nL : PeriodPair\nl₀ : ℂ\ns : Finset ↥L.lattice\ni : ↥L.lattice\nhi : i ∈ s\nh✝ : ¬↑i = l₀\n⊢ DifferentiableOn ℂ (fun z ↦ -2 / (z - ↑i) ^ 3) (↑L.lattice \\ {l₀})ᶜ",
"usedConstants": [
"NormedCommRing.toNormedRing",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSemin... | refine .div (by fun_prop) (by fun_prop) fun x hx ↦ ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | {
"line": 171,
"column": 50
} | {
"line": 180,
"column": 8
} | [
{
"pp": "n : ℕ\nP : ℝ[X]\nhP : P.degree ≤ ↑n\n⊢ sumNodes n (leadingCoeffC n) P = P.coeff n",
"usedConstants": [
"WithBot.addMonoidWithOne",
"WithBot.instPreorder",
"Eq.mpr",
"Polynomial.eval",
"WithBot.zeroLEOneClass",
"WithBot.addLeftMono",
"le_refl",
"Nat.in... | by
simp_rw [sumNodes, leadingCoeffC]
have : P.degree < (Finset.range (n + 1)).card := by
rw [Finset.card_range]
grw [hP]
norm_cast
simp
convert! (Lagrange.coeff_eq_sum (strictAntiOn_node n).injOn this).symm using 2
· exact Eq.symm (Nat.range_succ_eq_Iic n)
· simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | {
"line": 185,
"column": 2
} | {
"line": 185,
"column": 28
} | [
{
"pp": "n : ℕ\n⊢ (T ℝ ↑n).coeff n = 2 ^ (n - 1)",
"usedConstants": [
"Real",
"Polynomial.Chebyshev.T",
"CommSemiring.toSemiring",
"Nat.instAtLeastTwoHAddOfNat",
"HSub.hSub",
"Real.semiring",
"Polynomial.leadingCoeff",
"instSubNat",
"instOfNatNat",
... | trans (T ℝ n).leadingCoeff | Batteries.Tactic._aux_Batteries_Tactic_Trans___elabRules_Batteries_Tactic_tacticTrans____1 | Batteries.Tactic.tacticTrans___ |
Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | {
"line": 264,
"column": 50
} | {
"line": 264,
"column": 96
} | [
{
"pp": "n k i : ℕ\nhi : i ≤ n\nx : ℝ\nhx : 1 ≤ x\nt : Finset ℕ\na : ℕ\nx✝ : a ∈ t\n⊢ 0 ≤ x - node n a",
"usedConstants": [
"_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal.0.Polynomial.Chebyshev.negOnePow_mul_iterateDerivativeC_nonneg._proof_1_2"
]
}
] | by grind [show node n a ≤ 1 from cos_le_one _] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | {
"line": 273,
"column": 52
} | {
"line": 273,
"column": 98
} | [
{
"pp": "n k i : ℕ\nhk₁ : 0 < k\nhk₂ : k ≤ n\nhi : i ≤ n\nx : ℝ\nhx : 1 ≤ x\nt : Finset ℕ\nx✝¹ : t ∈ Finset.powersetCard (n - k) ((Finset.range (n + 1)).erase i)\na : ℕ\nx✝ : a ∈ t\n⊢ 0 ≤ x - node n a",
"usedConstants": [
"_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal.0.P... | by grind [show node n a ≤ 1 from cos_le_one _] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | {
"line": 521,
"column": 2
} | {
"line": 521,
"column": 34
} | [
{
"pp": "L : PeriodPair\nl₀ : ↥L.lattice\nz : ℂ\n⊢ ℘'[L - ↑l₀] z - 2 / (z - ↑l₀) ^ 3 = ℘'[L - ↑l₀] z + ∑' (i : ↥L.lattice), if ↑i = ↑l₀ then -2 / (z - ↑l₀) ^ 3 else 0",
"usedConstants": [
"NormedCommRing.toSeminormedCommRing",
"Submodule",
"neg_div",
"instHDiv",
"NonUnitalCommR... | · simp [sub_eq_add_neg, neg_div] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | {
"line": 682,
"column": 29
} | {
"line": 682,
"column": 61
} | [
{
"pp": "L : PeriodPair\nl₀ z x : ℂ\nhx : ∀ (l : ↥L.lattice), ↑l ≠ l₀ → ‖z - x‖ < ‖↑l - x‖\nκ : ℝ\nhκ : 1 < κ\nhκ' : ∀ (l : ↥L.lattice), ↑l ≠ l₀ → ‖z - x‖ * κ < ‖↑l - x‖\ne : ℕ × ↥L.lattice ≃ ↥L.lattice ⊕ ℕ × ↥L.lattice :=\n (Equiv.prodCongrLeft fun x ↦ (Denumerable.eqv (Option ℕ)).symm).trans optionProdEquiv\... | grind [abs_inv, inv_lt_one_iff₀] | Lean.Elab.Tactic.evalGrind | Lean.Parser.Tactic.grind |
Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | {
"line": 220,
"column": 4
} | {
"line": 220,
"column": 70
} | [
{
"pp": "case refine_1\nn k : ℕ\nhn : n ≠ 0\nhk₀ : 0 < k\nhk₁ : k < n\nhk₂ : Even k\nzero_lt : 0 < ↑k * π / ↑n\nlt_pi : ↑k * π / ↑n < π\nx : ℝ\nhx : x ∈ Set.Ioo (-1) 1\n⊢ eval x (T ℝ ↑n) ≤ eval (cos (↑k * π / ↑n)) (T ℝ ↑n)",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Polynomial.eval",
... | rw [(eval_T_real_eq_one_iff hn _).mpr ⟨k, le_of_lt hk₁, hk₂, rfl⟩] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | {
"line": 255,
"column": 11
} | {
"line": 266,
"column": 46
} | [
{
"pp": "k d : ℕ\n⊢ EqOn (iteratedDeriv k fun z ↦ cotTerm z d)\n (fun z ↦ (-1) ^ k * ↑k ! * ((z + (↑d + 1)) ^ (-1 - ↑k) + (z - (↑d + 1)) ^ (-1 - ↑k))) ℂ_ℤ",
"usedConstants": [
"neg_add_rev",
"Int.instAddCommGroup",
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"NormedCommRing.toNormed... | by
intro z hz
rw [← Pi.add_def, iteratedDeriv_add]
· have h2 := iter_deriv_inv_linear_sub k 1 ((d + 1 : ℂ))
have h3 := iter_deriv_inv_linear k 1 (d + 1 : ℂ)
simp only [one_div, one_mul, one_pow, mul_one, Int.reduceNeg, iteratedDeriv_eq_iterate] at *
rw [h2, h3]
ring
· simpa [sub_eq_add_neg] usin... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | {
"line": 364,
"column": 2
} | {
"line": 366,
"column": 78
} | [
{
"pp": "z : ℂ\nk : ℕ\nhk : 1 ≤ k\nhz : z ∈ ℍₒ\n⊢ (-1) ^ k * ↑k ! * z ^ (-1 - ↑k) + ∑' (n : ℕ), iteratedDerivWithin k (fun t ↦ cotTerm t n) ℍₒ z =\n (-1) ^ k * ↑k ! * ∑' (n : ℤ), (z + ↑n) ^ (-1 - ↑k)",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"No... | conv =>
enter [1, 2, 1, n]
rw [eqOn_iteratedDerivWithin_cotTerm_upperHalfPlaneSet k n (by simp [hz])] | Lean.Elab.Tactic.Conv.evalConv | Lean.Parser.Tactic.Conv.conv |
Mathlib.Analysis.SumIntegralComparisons | {
"line": 68,
"column": 4
} | {
"line": 68,
"column": 60
} | [
{
"pp": "a b : ℕ\nf g : ℝ → ℝ\nhab : a ≤ b\nh : ∀ i ∈ Ico a b, ∀ x ∈ Ico ↑i ↑(i + 1), f ↑i ≤ g x\nhg : IntegrableOn g (Ico ↑a ↑b) volume\nA : ∀ i ∈ Finset.Ico a b, IntervalIntegrable g volume ↑i ↑(i + 1)\ni : ℕ\nhi : i ∈ Finset.Ico a b\nx : ℝ\nhx : x ∈ Ioo ↑i ↑(i + 1)\n⊢ f ↑i ≤ g x",
"usedConstants": [
... | exact h _ (by simpa using hi) _ (Ioo_subset_Ico_self hx) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Analysis.SumIntegralExpDecay | {
"line": 34,
"column": 8
} | {
"line": 36,
"column": 61
} | [
{
"pp": "k : ℕ\nM c : ℝ\nhM : 0 ≤ M\nhc : 0 < c\nhk : 0 < ↑k + 1\nkey : ∫ (t : ℝ) in Ioi 0, t ^ (↑k + 1 - 1) * rexp (-(c * t)) = (1 / c) ^ (↑k + 1) * Gamma (↑k + 1)\nhint : IntegrableOn (fun x ↦ x ^ (↑k + 1 - 1) * rexp (-(c * x))) (Ioi 0) volume\n⊢ ∫ (x : ℝ) in Ioc 0 M, x ^ (↑k + 1 - 1) * rexp (-(c * x)) ≤ ∫ (x... | apply setIntegral_mono_set hint _ Ioc_subset_Ioi_self.eventuallyLE
filter_upwards [ae_restrict_mem measurableSet_Ioi] with x hx
exact mul_nonneg (rpow_nonneg hx.le _) (exp_nonneg _) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Analysis.SumIntegralExpDecay | {
"line": 34,
"column": 8
} | {
"line": 36,
"column": 61
} | [
{
"pp": "k : ℕ\nM c : ℝ\nhM : 0 ≤ M\nhc : 0 < c\nhk : 0 < ↑k + 1\nkey : ∫ (t : ℝ) in Ioi 0, t ^ (↑k + 1 - 1) * rexp (-(c * t)) = (1 / c) ^ (↑k + 1) * Gamma (↑k + 1)\nhint : IntegrableOn (fun x ↦ x ^ (↑k + 1 - 1) * rexp (-(c * x))) (Ioi 0) volume\n⊢ ∫ (x : ℝ) in Ioc 0 M, x ^ (↑k + 1 - 1) * rexp (-(c * x)) ≤ ∫ (x... | apply setIntegral_mono_set hint _ Ioc_subset_Ioi_self.eventuallyLE
filter_upwards [ae_restrict_mem measurableSet_Ioi] with x hx
exact mul_nonneg (rpow_nonneg hx.le _) (exp_nonneg _) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Preadditive.Yoneda.Projective | {
"line": 48,
"column": 4
} | {
"line": 49,
"column": 18
} | [
{
"pp": "case refine_1\nC : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Preadditive C\nP : C\nh : (preadditiveCoyonedaObj P ⋙ forget (ModuleCat (End P)ᵐᵒᵖ)).PreservesEpimorphisms\n⊢ (preadditiveCoyonedaObj P).PreservesEpimorphisms",
"usedConstants": [
"CategoryTheory.instFaithfulForget",
"Catego... | exact Functor.preservesEpimorphisms_of_preserves_of_reflects (preadditiveCoyonedaObj P)
(forget _) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Preadditive.Yoneda.Projective | {
"line": 48,
"column": 4
} | {
"line": 49,
"column": 18
} | [
{
"pp": "case refine_1\nC : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Preadditive C\nP : C\nh : (preadditiveCoyonedaObj P ⋙ forget (ModuleCat (End P)ᵐᵒᵖ)).PreservesEpimorphisms\n⊢ (preadditiveCoyonedaObj P).PreservesEpimorphisms",
"usedConstants": [
"CategoryTheory.instFaithfulForget",
"Catego... | exact Functor.preservesEpimorphisms_of_preserves_of_reflects (preadditiveCoyonedaObj P)
(forget _) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Preadditive.Yoneda.Projective | {
"line": 48,
"column": 4
} | {
"line": 49,
"column": 18
} | [
{
"pp": "case refine_1\nC : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Preadditive C\nP : C\nh : (preadditiveCoyonedaObj P ⋙ forget (ModuleCat (End P)ᵐᵒᵖ)).PreservesEpimorphisms\n⊢ (preadditiveCoyonedaObj P).PreservesEpimorphisms",
"usedConstants": [
"CategoryTheory.instFaithfulForget",
"Catego... | exact Functor.preservesEpimorphisms_of_preserves_of_reflects (preadditiveCoyonedaObj P)
(forget _) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Analysis.SpecificLimits.FloorPow | {
"line": 112,
"column": 10
} | {
"line": 112,
"column": 43
} | [
{
"pp": "case hbc\nu : ℕ → ℝ\nl : ℝ\nhmono : Monotone u\nhlim :\n ∀ (a : ℝ),\n 1 < a →\n ∃ c,\n (∀ᶠ (n : ℕ) in atTop, ↑(c (n + 1)) ≤ a * ↑(c n)) ∧\n Tendsto c atTop atTop ∧ Tendsto (fun n ↦ u (c n) / ↑(c n)) atTop (𝓝 l)\nlnonneg : 0 ≤ l\nA : ∀ (ε : ℝ), 0 < ε → ∀ᶠ (n : ℕ) in atTop, u n ... | refine le_trans (neg_le_abs _) ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | {
"line": 73,
"column": 53
} | {
"line": 73,
"column": 64
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Abelian C\nX Y Z : C\nf : X ⟶ Y\ng : Y ⟶ Z\n⊢ biprod.inl ≫ φ f g = f ≫ biprod.inl",
"usedConstants": [
"CategoryTheory.Abelian.toPreadditive",
"NegZeroClass.toNeg",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
... | by simp [φ] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | {
"line": 76,
"column": 61
} | {
"line": 76,
"column": 72
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Abelian C\nX Y Z : C\nf : X ⟶ Y\ng : Y ⟶ Z\n⊢ biprod.inr ≫ φ f g ≫ biprod.fst = -𝟙 Y",
"usedConstants": [
"CategoryTheory.Abelian.toPreadditive",
"NegZeroClass.toNeg",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
... | by simp [φ] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Analysis.SpecificLimits.FloorPow | {
"line": 253,
"column": 27
} | {
"line": 253,
"column": 28
} | [
{
"pp": "N : ℕ\nj : ℝ\nhj : 0 < j\nc : ℝ\nhc : 1 < c\ncpos : 0 < c\nA : 0 < c⁻¹ ^ 2\nB : c ^ 2 * (1 - c⁻¹ ^ 2)⁻¹ ≤ c ^ 3 * (c - 1)⁻¹\nC : c⁻¹ ^ 2 < 1\nI : (c⁻¹ ^ 2) ^ (Real.log j / Real.log c) = 1 / j ^ 2\n⊢ (c⁻¹ ^ 2) ^ (Real.log j / Real.log c) / (c⁻¹ ^ 2) ^ 1 / (1 - c⁻¹ ^ 2) = c ^ 2 * (1 - c⁻¹ ^ 2)⁻¹ / j ^ 2"... | I | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite | {
"line": 62,
"column": 2
} | {
"line": 64,
"column": 39
} | [
{
"pp": "C : Type u\ninst✝⁴ : Category.{v, u} C\nD : Type v\ninst✝³ : SmallCategory D\nF : D ⥤ Cᵒᵖ\ninst✝² : Abelian C\ninst✝¹ : IsGrothendieckAbelian.{v, v, u} C\ninst✝ : Nonempty D\n⊢ IsSeparator (generator F)",
"usedConstants": [
"CategoryTheory.Abelian.toPreadditive",
"Classical.ofNonempty",... | apply isSeparator_sigma_of_isSeparator _ Classical.ofNonempty
apply isSeparator_sigma_of_isSeparator _ 0
exact isSeparator_projectiveSeparator | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite | {
"line": 62,
"column": 2
} | {
"line": 64,
"column": 39
} | [
{
"pp": "C : Type u\ninst✝⁴ : Category.{v, u} C\nD : Type v\ninst✝³ : SmallCategory D\nF : D ⥤ Cᵒᵖ\ninst✝² : Abelian C\ninst✝¹ : IsGrothendieckAbelian.{v, v, u} C\ninst✝ : Nonempty D\n⊢ IsSeparator (generator F)",
"usedConstants": [
"CategoryTheory.Abelian.toPreadditive",
"Classical.ofNonempty",... | apply isSeparator_sigma_of_isSeparator _ Classical.ofNonempty
apply isSeparator_sigma_of_isSeparator _ 0
exact isSeparator_projectiveSeparator | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Filtered.Small | {
"line": 262,
"column": 6
} | {
"line": 263,
"column": 22
} | [
{
"pp": "case base.refine_1\nC : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : IsCofilteredOrEmpty C\nα : Type w\nf : α → C\nj : C\nx : α\n⊢ (CofilteredClosureSmall.bundledAbstractCofilteredClosure f 0).fst",
"usedConstants": [
"id",
"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory... | simp only [CofilteredClosureSmall.bundledAbstractCofilteredClosure]
exact ULift.up x | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Filtered.Small | {
"line": 262,
"column": 6
} | {
"line": 263,
"column": 22
} | [
{
"pp": "case base.refine_1\nC : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : IsCofilteredOrEmpty C\nα : Type w\nf : α → C\nj : C\nx : α\n⊢ (CofilteredClosureSmall.bundledAbstractCofilteredClosure f 0).fst",
"usedConstants": [
"id",
"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory... | simp only [CofilteredClosureSmall.bundledAbstractCofilteredClosure]
exact ULift.up x | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | {
"line": 156,
"column": 2
} | {
"line": 156,
"column": 23
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nI : Type v\ninst✝¹ : SmallCategory I\ninst✝ : IsFiltered I\nF : I ⥤ Cᵒᵖ ⥤ Type v\nhF : ∀ (i : I), IsIndObject (F.obj i)\nthis : IsFiltered (CostructuredArrow yoneda (colimit F))\ns : (i : I) → Set (CostructuredArrow yoneda (F.obj i))\nhs : ∀ (i : I), Small.{v, ma... | obtain ⟨x⟩ := hj _ y' | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.CategoryTheory.Preadditive.Yoneda.Injective | {
"line": 47,
"column": 2
} | {
"line": 48,
"column": 11
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Preadditive C\nJ : C\n⊢ (yoneda.obj J).PreservesEpimorphisms ↔ (preadditiveYonedaObj J).PreservesEpimorphisms",
"usedConstants": [
"CategoryTheory.Functor",
"Opposite",
"ModuleCat",
"AddCommGroup.toAddCommMonoid",
"Catego... | refine ⟨fun h : (preadditiveYonedaObj J ⋙ (forget <| ModuleCat (End J))).PreservesEpimorphisms =>
?_, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.CategoryTheory.Abelian.Injective.Resolution | {
"line": 226,
"column": 8
} | {
"line": 226,
"column": 48
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Abelian C\ninst✝ : HasInjectiveResolutions C\nX : C\n⊢ (HomotopyCategory.quotient C (ComplexShape.up ℕ)).map\n (InjectiveResolution.desc (𝟙 X) (injectiveResolution X) (injectiveResolution X)) =\n 𝟙 ((HomotopyCategory.quotient C (ComplexShape.up... | ← (HomotopyCategory.quotient _ _).map_id | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Abelian.Pseudoelements | {
"line": 342,
"column": 6
} | {
"line": 352,
"column": 15
} | [
{
"pp": "case h.a\nC : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Abelian C\nS : ShortComplex C\nhS : S.Exact\nb' : Pseudoelement S.X₂\nb : Over S.X₂\nhb : pseudoApply S.g ⟦b⟧ = 0\nhb' : b.hom ≫ S.g = 0\nc : b.left ⟶ (KernelFork.ofι (image.ι S.f) ⋯).pt\nhc : c ≫ Fork.ι (KernelFork.ofι (image.ι S.f) ⋯) = b.hom\... | calc
𝟙 (pullback (Abelian.factorThruImage S.f) c) ≫ pullback.fst _ _ ≫ S.f =
pullback.fst _ _ ≫ S.f :=
Category.id_comp _
_ = pullback.fst _ _ ≫ Abelian.factorThruImage S.f ≫ kernel.ι (cokernel.π S.f) := by
rw [Abelian.image.fac]
_ = (pullback.snd _ _ ≫ c) ≫ kernel... | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcTactic |
Mathlib.CategoryTheory.Abelian.SerreClass.Localization | {
"line": 170,
"column": 8
} | {
"line": 170,
"column": 28
} | [
{
"pp": "C : Type u\ninst✝⁶ : Category.{v, u} C\ninst✝⁵ : Abelian C\nD : Type u'\ninst✝⁴ : Category.{v', u'} D\nL : C ⥤ D\nP : ObjectProperty C\ninst✝³ : P.IsSerreClass\ninst✝² : L.IsLocalization P.isoModSerre\ninst✝¹ : Preadditive D\ninst✝ : L.Additive\nX Y : C\nf : X ⟶ Y\nthis : L.EssSurj\ntfae_1_to_2 : Mono ... | map_eq_zero_iff L P, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Action | {
"line": 175,
"column": 6
} | {
"line": 179,
"column": 9
} | [
{
"pp": "M : Type u_1\ninst✝⁴ : Monoid M\nX : Type u\ninst✝³ : MulAction M X\nx : X\nG : Type u_2\ninst✝² : Group G\ninst✝¹ : MulAction G X\nH : Type u_3\ninst✝ : Group H\nF : ActionCategory G X ⥤ SingleObj H\nF_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair b.back ↑f)\n⊢ ⟨fun b ↦... | dsimp
ext1
· ext b
exact F_map_eq.symm.trans (F.map_id b)
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Action | {
"line": 175,
"column": 6
} | {
"line": 179,
"column": 9
} | [
{
"pp": "M : Type u_1\ninst✝⁴ : Monoid M\nX : Type u\ninst✝³ : MulAction M X\nx : X\nG : Type u_2\ninst✝² : Group G\ninst✝¹ : MulAction G X\nH : Type u_3\ninst✝ : Group H\nF : ActionCategory G X ⥤ SingleObj H\nF_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair b.back ↑f)\n⊢ ⟨fun b ↦... | dsimp
ext1
· ext b
exact F_map_eq.symm.trans (F.map_id b)
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Abelian.SerreClass.Localization | {
"line": 203,
"column": 8
} | {
"line": 203,
"column": 28
} | [
{
"pp": "C : Type u\ninst✝⁶ : Category.{v, u} C\ninst✝⁵ : Abelian C\nD : Type u'\ninst✝⁴ : Category.{v', u'} D\nL : C ⥤ D\nP : ObjectProperty C\ninst✝³ : P.IsSerreClass\ninst✝² : L.IsLocalization P.isoModSerre\ninst✝¹ : Preadditive D\ninst✝ : L.Additive\nX Y : C\nf : X ⟶ Y\nthis : L.EssSurj\ntfae_1_to_2 : Epi (... | map_eq_zero_iff L P, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Adjunction.Lifting.Left | {
"line": 90,
"column": 52
} | {
"line": 90,
"column": 65
} | [
{
"pp": "case refine_1\nA : Type u₁\nB : Type u₂\nC : Type u₃\ninst✝² : Category.{v₁, u₁} A\ninst✝¹ : Category.{v₂, u₂} B\ninst✝ : Category.{v₃, u₃} C\nU : B ⥤ C\nF : C ⥤ B\nR : A ⥤ B\nF' : C ⥤ A\nadj₁ : F ⊣ U\nadj₂ : F' ⊣ R ⋙ U\nh : (X : B) → RegularEpi (adj₁.counit.app X)\nX : B\ns : Cofork (F.map (U.map (adj... | ← U.map_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Adjunction.Lifting.Left | {
"line": 149,
"column": 35
} | {
"line": 149,
"column": 48
} | [
{
"pp": "A : Type u₁\nB : Type u₂\nC : Type u₃\ninst✝³ : Category.{v₁, u₁} A\ninst✝² : Category.{v₂, u₂} B\ninst✝¹ : Category.{v₃, u₃} C\nU : B ⥤ C\nF : C ⥤ B\nR : A ⥤ B\nF' : C ⥤ A\nadj₁ : F ⊣ U\nadj₂ : F' ⊣ R ⋙ U\ninst✝ : HasReflexiveCoequalizers A\nh : (X : B) → RegularEpi (adj₁.counit.app X)\nY : A\nX : B\n... | ← U.map_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Adjunction.Lifting.Left | {
"line": 154,
"column": 6
} | {
"line": 154,
"column": 49
} | [
{
"pp": "A : Type u₁\nB : Type u₂\nC : Type u₃\ninst✝³ : Category.{v₁, u₁} A\ninst✝² : Category.{v₂, u₂} B\ninst✝¹ : Category.{v₃, u₃} C\nU : B ⥤ C\nF : C ⥤ B\nR : A ⥤ B\nF' : C ⥤ A\nadj₁ : F ⊣ U\nadj₂ : F' ⊣ R ⋙ U\ninst✝ : HasReflexiveCoequalizers A\nh : (X : B) → RegularEpi (adj₁.counit.app X)\nY : A\nX : B\n... | apply (adj₁.homEquiv _ _).symm.subtypeEquiv | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.CategoryTheory.Adjunction.Lifting.Right | {
"line": 92,
"column": 34
} | {
"line": 92,
"column": 47
} | [
{
"pp": "case refine_1\nA : Type u₁\nB : Type u₂\nC : Type u₃\ninst✝² : Category.{v₁, u₁} A\ninst✝¹ : Category.{v₂, u₂} B\ninst✝ : Category.{v₃, u₃} C\nU : A ⥤ B\nF : B ⥤ A\nL : C ⥤ B\nU' : A ⥤ C\nadj₁ : F ⊣ U\nadj₂ : L ⋙ F ⊣ U'\nh : (X : B) → RegularMono (adj₁.unit.app X)\nX : B\ns : Fork (U.map (F.map (adj₁.u... | ← U.map_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {
"line": 308,
"column": 14
} | {
"line": 308,
"column": 32
} | [
{
"pp": "B : Type u₁\ninst✝² : Bicategory B\nC : Type u₂\ninst✝¹ : Bicategory C\nD : Type u₃\ninst✝ : Bicategory D\nF : StrictlyUnitaryPseudofunctor B C\nx : B\n⊢ F.toLax.map (𝟙 x) = 𝟙 (F.toLax.obj x)",
"usedConstants": [
"CategoryTheory.Pseudofunctor.toLax",
"CategoryTheory.StrictlyUnitaryPse... | by simp [F.map_id] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Sigma.Basic | {
"line": 100,
"column": 16
} | {
"line": 102,
"column": 26
} | [
{
"pp": "I : Type w₁\nC : I → Type u₁\ninst✝¹ : (i : I) → Category.{v₁, u₁} (C i)\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nF✝ : (i : I) → C i ⥤ D\nF G : (i : I) × C i ⥤ D\nh : (i : I) → incl i ⋙ F ⟶ incl i ⋙ G\n⊢ ∀ ⦃X Y : (i : I) × C i⦄ (f : X ⟶ Y),\n (F.map f ≫\n match Y with\n | ⟨j, X⟩ => (... | by
rintro ⟨j, X⟩ ⟨_, _⟩ ⟨f⟩
apply (h j).naturality | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.PFun | {
"line": 535,
"column": 2
} | {
"line": 535,
"column": 56
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nf : α →. β\ng : α →. γ\nx : α\ny : β × γ\n⊢ y ∈ f.prodLift g x ↔ y.1 ∈ f x ∧ y.2 ∈ g x",
"usedConstants": [
"Part",
"PFun.prodLift",
"Membership.mem",
"Exists",
"Part.instMembership",
"Part.get",
"Prod.fst",
"... | trans ∃ hp hq, (f x).get hp = y.1 ∧ (g x).get hq = y.2 | Batteries.Tactic._aux_Batteries_Tactic_Trans___elabRules_Batteries_Tactic_tacticTrans____1 | Batteries.Tactic.tacticTrans___ |
Mathlib.CategoryTheory.Dialectica.Monoidal | {
"line": 151,
"column": 4
} | {
"line": 151,
"column": 70
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : HasFiniteProducts C\ninst✝ : HasPullbacks C\nX Y : Dial C\n⊢ (X ⊗ Y).rel =\n (Subobject.pullback (prod.map (prod.braiding X.src Y.src).hom (prod.braiding X.tgt Y.tgt).hom)).obj (Y ⊗ X).rel",
"usedConstants": [
"_private.Mathlib.CategoryTheor... | simp [Subobject.inf_pullback, ← Subobject.pullback_comp, inf_comm] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Dialectica.Monoidal | {
"line": 151,
"column": 4
} | {
"line": 151,
"column": 70
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : HasFiniteProducts C\ninst✝ : HasPullbacks C\nX Y : Dial C\n⊢ (X ⊗ Y).rel =\n (Subobject.pullback (prod.map (prod.braiding X.src Y.src).hom (prod.braiding X.tgt Y.tgt).hom)).obj (Y ⊗ X).rel",
"usedConstants": [
"_private.Mathlib.CategoryTheor... | simp [Subobject.inf_pullback, ← Subobject.pullback_comp, inf_comm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Dialectica.Monoidal | {
"line": 151,
"column": 4
} | {
"line": 151,
"column": 70
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : HasFiniteProducts C\ninst✝ : HasPullbacks C\nX Y : Dial C\n⊢ (X ⊗ Y).rel =\n (Subobject.pullback (prod.map (prod.braiding X.src Y.src).hom (prod.braiding X.tgt Y.tgt).hom)).obj (Y ⊗ X).rel",
"usedConstants": [
"_private.Mathlib.CategoryTheor... | simp [Subobject.inf_pullback, ← Subobject.pullback_comp, inf_comm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Localization.StructuredArrow | {
"line": 81,
"column": 2
} | {
"line": 86,
"column": 81
} | [
{
"pp": "C : Type u_1\ninst✝ : Category.{v_1, u_1} C\nW : MorphismProperty C\nX : C\nP : StructuredArrow (W.Q.obj X) W.Q → Prop\nhP₀ : P (StructuredArrow.mk (𝟙 (W.Q.obj X)))\nhP₁ :\n ∀ ⦃Y₁ Y₂ : C⦄ (f : Y₁ ⟶ Y₂) (φ : W.Q.obj X ⟶ W.Q.obj Y₁),\n P (StructuredArrow.mk φ) → P (StructuredArrow.mk (φ ≫ W.Q.map f)... | induction f with
| nil => exact hP₀
| cons f g hf =>
obtain (g | ⟨w, hw⟩) := g
· exact hP₁ g _ hf
· simpa only [← Construction.wInv_eq_isoOfHom_inv w hw] using hP₂ w hw _ hf | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.CategoryTheory.Functor.Derived.RightDerived | {
"line": 107,
"column": 2
} | {
"line": 108,
"column": 6
} | [
{
"pp": "C : Type u_1\nD : Type u_3\nH : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_3, u_3} D\ninst✝² : Category.{v_5, u_2} H\nRF RF' : D ⥤ H\nF F' : C ⥤ H\nL : C ⥤ D\nα : F ⟶ L ⋙ RF\nα' : F' ⟶ L ⋙ RF'\nW : MorphismProperty C\ninst✝¹ : L.IsLocalization W\ninst✝ : RF.IsRightDerivedFunctor α W... | dsimp only [rightDerivedNatTrans]
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Functor.Derived.RightDerived | {
"line": 107,
"column": 2
} | {
"line": 108,
"column": 6
} | [
{
"pp": "C : Type u_1\nD : Type u_3\nH : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_3, u_3} D\ninst✝² : Category.{v_5, u_2} H\nRF RF' : D ⥤ H\nF F' : C ⥤ H\nL : C ⥤ D\nα : F ⟶ L ⋙ RF\nα' : F' ⟶ L ⋙ RF'\nW : MorphismProperty C\ninst✝¹ : L.IsLocalization W\ninst✝ : RF.IsRightDerivedFunctor α W... | dsimp only [rightDerivedNatTrans]
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Functor.Derived.RightDerived | {
"line": 115,
"column": 2
} | {
"line": 116,
"column": 6
} | [
{
"pp": "C : Type u_1\nD : Type u_3\nH : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_3, u_3} D\ninst✝² : Category.{v_5, u_2} H\nRF RF' : D ⥤ H\nF F' : C ⥤ H\nL : C ⥤ D\nα : F ⟶ L ⋙ RF\nα' : F' ⟶ L ⋙ RF'\nW : MorphismProperty C\ninst✝¹ : L.IsLocalization W\ninst✝ : RF.IsRightDerivedFunctor α W... | dsimp only [rightDerivedNatTrans]
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Functor.Derived.RightDerived | {
"line": 115,
"column": 2
} | {
"line": 116,
"column": 6
} | [
{
"pp": "C : Type u_1\nD : Type u_3\nH : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_3, u_3} D\ninst✝² : Category.{v_5, u_2} H\nRF RF' : D ⥤ H\nF F' : C ⥤ H\nL : C ⥤ D\nα : F ⟶ L ⋙ RF\nα' : F' ⟶ L ⋙ RF'\nW : MorphismProperty C\ninst✝¹ : L.IsLocalization W\ninst✝ : RF.IsRightDerivedFunctor α W... | dsimp only [rightDerivedNatTrans]
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Functor.Derived.PointwiseRightDerived | {
"line": 87,
"column": 26
} | {
"line": 89,
"column": 18
} | [
{
"pp": "C : Type u₁\nH : Type u₃\ninst✝² : Category.{v₁, u₁} C\ninst✝¹ : Category.{v₃, u₃} H\nF : C ⥤ H\nW : MorphismProperty C\ninst✝ : F.HasPointwiseRightDerivedFunctor W\n⊢ W.Q.HasLeftKanExtension F",
"usedConstants": [
"CategoryTheory.Functor.HasLeftKanExtension",
"CategoryTheory.MorphismPr... | by
have := F.hasPointwiseLeftKanExtension_of_hasPointwiseRightDerivedFunctor W.Q W
infer_instance | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Galois.Decomposition | {
"line": 102,
"column": 6
} | {
"line": 102,
"column": 75
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{u₂, u₁} C\ninst✝¹ : GaloisCategory C\nF : C ⥤ FintypeCat\ninst✝ : FiberFunctor F\nn : ℕ\nhi : ∀ m < n, ∀ (X : C), m = Nat.card (F.obj X).obj → ∃ ι f g x, (∀ (i : ι), IsConnected (f i)) ∧ Finite ι\nX : C\nhn : n = Nat.card (F.obj X).obj\nh : ¬IsConnected X\nnhi : ∀ (a : I... | exact Nat.pos_of_ne_zero (non_zero_card_fiber_of_not_initial F Y hni) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Galois.Prorepresentability | {
"line": 332,
"column": 6
} | {
"line": 332,
"column": 59
} | [
{
"pp": "case h.toFun.h\nC : Type u₁\ninst✝² : Category.{u₂, u₁} C\ninst✝¹ : GaloisCategory C\nF : C ⥤ FintypeCat\ninst✝ : FiberFunctor F\nX✝ Y✝ : PointedGaloisObject F\nf : X✝ ⟶ Y✝\nx✝ : (autGaloisSystem F ⋙ forget GrpCat).obj X✝\n⊢ (ConcreteCategory.hom\n ((autGaloisSystem F ⋙ forget GrpCat).map f ≫\... | simp [evaluationEquivOfIsGalois, -Hom.comp, ← f.comp] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Groupoid.Basic | {
"line": 32,
"column": 13
} | {
"line": 32,
"column": 62
} | [
{
"pp": "C : Type u_1\ninst✝ : Groupoid C\nh : ∀ (c : C), Subsingleton (c ⟶ c)\nc d : C\nf g : c ⟶ d\nthis : Subsingleton (d ⟶ d)\n⊢ f ≫ inv f ≫ g = g",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Groupoid.inv",
"Catego... | by simp only [inv_eq_inv, IsIso.hom_inv_id_assoc] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Groupoid.FreeGroupoid | {
"line": 88,
"column": 61
} | {
"line": 111,
"column": 14
} | [
{
"pp": "V : Type u\ninst✝ : Quiver V\nX Y : Paths (Symmetrify V)\np : X ⟶ Y\n⊢ Quot.mk (HomRel.CompClosure redStep) (p ≫ Path.reverse p) = Quot.mk (HomRel.CompClosure redStep) (𝟙 X)",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"Quot.eqvGen_sound",
"CategoryTheory... | by
apply Quot.eqvGen_sound
induction p with
| nil => apply EqvGen.refl
| cons q f ih =>
simp only [Quiver.Path.reverse]
fapply EqvGen.trans
-- Porting note: dot notation for `Quiver.Path.*` and `Quiver.Hom.*` not working
· exact q ≫ Quiver.Path.reverse q
· apply EqvGen.symm
apply EqvGe... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.GuitartExact.HorizontalComposition | {
"line": 114,
"column": 2
} | {
"line": 116,
"column": 77
} | [
{
"pp": "C₁ : Type u_1\nC₂ : Type u_2\nC₃ : Type u_3\nD₁ : Type u_4\nD₂ : Type u_5\nD₃ : Type u_6\ninst✝⁸ : Category.{v_1, u_1} C₁\ninst✝⁷ : Category.{v_2, u_2} C₂\ninst✝⁶ : Category.{v_3, u_3} C₃\ninst✝⁵ : Category.{v_4, u_4} D₁\ninst✝⁴ : Category.{v_5, u_5} D₂\ninst✝³ : Category.{v_6, u_6} D₃\nV₁ : C₁ ⥤ D₁\nT... | have : (w.costructuredArrowRightwards (B₁.objPreimage Y₂) ⋙
w'.costructuredArrowRightwards (B₁.obj (B₁.objPreimage Y₂))).Final :=
(Functor.final_of_natIso (costructuredArrowRightwardsComp w w' _).symm :) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.CategoryTheory.LiftingProperties.PushoutProduct | {
"line": 98,
"column": 2
} | {
"line": 98,
"column": 32
} | [
{
"pp": "C : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasPushouts C\ninst✝² : HasPullbacks C\ninst✝¹ : MonoidalCategory C\ninst✝ : MonoidalClosed C\nA B K L X Y : C\nf : A ⟶ B\ng : K ⟶ L\nt : IsTerminal Y\n⊢ HasLiftingProperty (Arrow.mk f □ Arrow.mk g).hom (t.from X) ↔ HasLiftingProperty g ((MonoidalClosed.... | rw [hasLiftingProperty_mk_iff] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.LiftingProperties.ParametrizedAdjunction | {
"line": 166,
"column": 2
} | {
"line": 168,
"column": 55
} | [
{
"pp": "case mp\nC₁ : Type u₁\nC₂ : Type u₂\nC₃ : Type u₃\ninst✝² : Category.{v₁, u₁} C₁\ninst✝¹ : Category.{v₂, u₂} C₂\ninst✝ : Category.{v₃, u₃} C₃\nF : C₁ ⥤ C₂ ⥤ C₃\nG : C₁ᵒᵖ ⥤ C₃ ⥤ C₂\nadj₂ : F ⊣₂ G\nX₁ Y₁ : C₁\nf₁ : X₁ ⟶ Y₁\nX₂ Y₂ : C₂\nf₂ : X₂ ⟶ Y₂\nX₃ Y₃ : C₃\nf₃ : X₃ ⟶ Y₃\nsq₁₂ : F.PushoutObjObj f₁ f₂\... | · intro h β
obtain ⟨α, rfl⟩ := (adj₂.arrowHomEquiv sq₁₂ sq₁₃).surjective β
exact ⟨adj₂.liftStructEquiv sq₁₂ sq₁₃ α (h α).some⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.CategoryTheory.Join.Pseudofunctor | {
"line": 142,
"column": 22
} | {
"line": 142,
"column": 92
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\n⊢ ∀ {a b : Cat} (f : a ⟶ b),\n NatTrans.toCatHom₂ (mapWhiskerLeft (𝟭 C) (λ_ f).hom.toNatTrans) =\n (Cat.Hom.isoMk (mapCompRight C (𝟙 a).toFunctor f.toFunctor)).hom ≫\n (Cat.Hom.isoMk mapPairId).hom ▷ (mapPair (𝟭 C) f.toFunctor).toCatHom ≫\n ... | by intros; exact congr($(mapWhiskerLeft_leftUnitor_hom C _).toCatHom₂) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Types.End | {
"line": 72,
"column": 29
} | {
"line": 72,
"column": 87
} | [
{
"pp": "case mk\nJ : Type u\ninst✝ : Category.{v, u} J\nF : Jᵒᵖ ⥤ J ⥤ Type (max w u)\ns : Cocone (multispanIndexCoend F).multispan\nj✝ j'✝ : J\nf : j✝ ⟶ j'✝\nx : (F.obj (op j'✝)).obj j✝\n⊢ (fun x ↦ (hom (Multicofork.π s x.fst)) x.snd) ⟨j✝, (Hom.hom ((F.map f.op).app j✝)) x⟩ =\n (fun x ↦ (hom (Multicofork.π ... | exact ConcreteCategory.congr_hom (Cowedge.condition s f) _ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Limits.Types.End | {
"line": 72,
"column": 29
} | {
"line": 72,
"column": 87
} | [
{
"pp": "case mk\nJ : Type u\ninst✝ : Category.{v, u} J\nF : Jᵒᵖ ⥤ J ⥤ Type (max w u)\ns : Cocone (multispanIndexCoend F).multispan\nj✝ j'✝ : J\nf : j✝ ⟶ j'✝\nx : (F.obj (op j'✝)).obj j✝\n⊢ (fun x ↦ (hom (Multicofork.π s x.fst)) x.snd) ⟨j✝, (Hom.hom ((F.map f.op).app j✝)) x⟩ =\n (fun x ↦ (hom (Multicofork.π ... | exact ConcreteCategory.congr_hom (Cowedge.condition s f) _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Types.End | {
"line": 72,
"column": 29
} | {
"line": 72,
"column": 87
} | [
{
"pp": "case mk\nJ : Type u\ninst✝ : Category.{v, u} J\nF : Jᵒᵖ ⥤ J ⥤ Type (max w u)\ns : Cocone (multispanIndexCoend F).multispan\nj✝ j'✝ : J\nf : j✝ ⟶ j'✝\nx : (F.obj (op j'✝)).obj j✝\n⊢ (fun x ↦ (hom (Multicofork.π s x.fst)) x.snd) ⟨j✝, (Hom.hom ((F.map f.op).app j✝)) x⟩ =\n (fun x ↦ (hom (Multicofork.π ... | exact ConcreteCategory.congr_hom (Cowedge.condition s f) _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Localization.DerivabilityStructure.OfLocalizedEquivalences | {
"line": 158,
"column": 4
} | {
"line": 168,
"column": 55
} | [
{
"pp": "C₁ : Type u_1\nC₂ : Type u_2\nD₁ : Type u_3\nD₂ : Type u_4\ninst✝⁹ : Category.{v_1, u_1} C₁\ninst✝⁸ : Category.{v_2, u_2} C₂\ninst✝⁷ : Category.{v_3, u_3} D₁\ninst✝⁶ : Category.{v_4, u_4} D₂\nW₁ : MorphismProperty C₁\nW₁' : MorphismProperty D₁\nW₂ : MorphismProperty C₂\nW₂' : MorphismProperty D₂\nT : L... | let e : B.functor ⋙ R.inv.functor ≅ L.inv.functor ⋙ T.functor :=
(leftUnitor _).symm ≪≫
isoWhiskerRight L.functor.asEquivalence.counitIso.symm _ ≪≫
associator _ _ _ ≪≫ isoWhiskerLeft _ (associator _ _ _).symm ≪≫
isoWhiskerLeft _ (isoWhiskerRight iso.symm R.inv.functor) ≪≫
isoWhiske... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Localization.DerivabilityStructure.OfLocalizedEquivalences | {
"line": 158,
"column": 4
} | {
"line": 168,
"column": 55
} | [
{
"pp": "C₁ : Type u_1\nC₂ : Type u_2\nD₁ : Type u_3\nD₂ : Type u_4\ninst✝⁹ : Category.{v_1, u_1} C₁\ninst✝⁸ : Category.{v_2, u_2} C₂\ninst✝⁷ : Category.{v_3, u_3} D₁\ninst✝⁶ : Category.{v_4, u_4} D₂\nW₁ : MorphismProperty C₁\nW₁' : MorphismProperty D₁\nW₂ : MorphismProperty C₂\nW₂' : MorphismProperty D₂\nT : L... | let e : B.functor ⋙ R.inv.functor ≅ L.inv.functor ⋙ T.functor :=
(leftUnitor _).symm ≪≫
isoWhiskerRight L.functor.asEquivalence.counitIso.symm _ ≪≫
associator _ _ _ ≪≫ isoWhiskerLeft _ (associator _ _ _).symm ≪≫
isoWhiskerLeft _ (isoWhiskerRight iso.symm R.inv.functor) ≪≫
isoWhiske... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Free.Basic | {
"line": 354,
"column": 8
} | {
"line": 355,
"column": 38
} | [
{
"pp": "case triangle\nC : Type u\nD : Type u'\ninst✝¹ : Category.{v', u'} D\ninst✝ : MonoidalCategory D\nf✝ : C → D\nX Y : failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation)\nf g : failed to pretty print expression (use 'set_option pp.rawOnError true' for raw repres... | dsimp only [projectMapAux, projectObj]
rw [MonoidalCategory.triangle] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Monoidal.Free.Basic | {
"line": 354,
"column": 8
} | {
"line": 355,
"column": 38
} | [
{
"pp": "case triangle\nC : Type u\nD : Type u'\ninst✝¹ : Category.{v', u'} D\ninst✝ : MonoidalCategory D\nf✝ : C → D\nX Y : failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation)\nf g : failed to pretty print expression (use 'set_option pp.rawOnError true' for raw repres... | dsimp only [projectMapAux, projectObj]
rw [MonoidalCategory.triangle] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | {
"line": 216,
"column": 2
} | {
"line": 216,
"column": 41
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nY Z X : C\nf : Y ⟶ X\ng : Z ⟶ X\ninst✝ : ChosenPullbacksAlong g\nW : C\nφ₁ φ₂ : W ⟶ pullbackObj f g\nh₁ : φ₁ ≫ fst f g = φ₂ ≫ fst f g\nh₂ : φ₁ ≫ snd f g = φ₂ ≫ snd f g\nadj : map g ⊣ pullback g := mapPullbackAdj g\nU : Over Z := Over.mk (φ₁ ≫ snd f g)\nφ₁' : U... | exact congr_arg CommaMorphism.left this | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | {
"line": 235,
"column": 2
} | {
"line": 235,
"column": 41
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nY Z X : C\nf : Y ⟶ X\ng : Z ⟶ X\ninst✝ : ChosenPullbacksAlong g\nW : C\na : W ⟶ Y\nb : W ⟶ Z\nh : a ≫ f = b ≫ g\nadj : map g ⊣ pullback g := mapPullbackAdj g\na' : (map g).obj (Over.mk b) ⟶ Over.mk f := homMk a h\nthis : (map g).map ((adj.homEquiv (Over.mk b) ... | exact congr_arg CommaMorphism.left this | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Monoidal.Cartesian.Normal | {
"line": 98,
"column": 6
} | {
"line": 98,
"column": 36
} | [
{
"pp": "case refine_2.refine_2\nC : Type u_1\ninst✝⁵ : Category.{v_1, u_1} C\ninst✝⁴ : CartesianMonoidalCategory C\nG H : C\ninst✝³ : GrpObj G\ninst✝² : GrpObj H\nφ : H ⟶ G\ninst✝¹ : IsMonHom φ\ninst✝ : Mono φ\nhnormal : ∀ (X : C), (monoidHom φ X).range.Normal\nh' : (X : C) → (X ⟶ G) → (X ⟶ H) → (X ⟶ H)\nhh' :... | refine yoneda.map_injective ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.CategoryTheory.Subterminal | {
"line": 94,
"column": 12
} | {
"line": 94,
"column": 29
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nA : C\nhA : IsSubterminal A\ninst✝ : HasBinaryProduct A A\n⊢ prod.fst ≫ diag A = 𝟙 (A ⨯ A)",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Eq.mp",
"CategoryTheory.IsSubterminal.def",
... | IsSubterminal.def | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Monoidal.Closed.Ideal | {
"line": 146,
"column": 10
} | {
"line": 155,
"column": 84
} | [
{
"pp": "case e\nC : Type u₁\nD : Type u₂\ninst✝³ : Category.{v₁, u₁} C\ninst✝² : Category.{v₁, u₂} D\ni : D ⥤ C\ninst✝¹ : CartesianMonoidalCategory C\ninst✝ : Reflective i\nX Y : D\n⊢ ((Cone.postcompose (pairComp X Y i).hom).obj\n (i.mapCone\n (BinaryFan.mk ((reflector i).map (fst (i.obj X) (i.... | change (reflector i ⋙ i).obj (i.obj X ⊗ i.obj Y) ≅ (𝟭 C).obj (i.obj X ⊗ i.obj Y)
letI : IsIso ((reflectorAdjunction i).unit.app (i.obj X ⊗ i.obj Y)) := by
apply Functor.essImage.unit_isIso
haveI := reflective_products i
use Limits.prod X Y
constructor
... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Monoidal.Closed.Ideal | {
"line": 146,
"column": 10
} | {
"line": 155,
"column": 84
} | [
{
"pp": "case e\nC : Type u₁\nD : Type u₂\ninst✝³ : Category.{v₁, u₁} C\ninst✝² : Category.{v₁, u₂} D\ni : D ⥤ C\ninst✝¹ : CartesianMonoidalCategory C\ninst✝ : Reflective i\nX Y : D\n⊢ ((Cone.postcompose (pairComp X Y i).hom).obj\n (i.mapCone\n (BinaryFan.mk ((reflector i).map (fst (i.obj X) (i.... | change (reflector i ⋙ i).obj (i.obj X ⊗ i.obj Y) ≅ (𝟭 C).obj (i.obj X ⊗ i.obj Y)
letI : IsIso ((reflectorAdjunction i).unit.app (i.obj X ⊗ i.obj Y)) := by
apply Functor.essImage.unit_isIso
haveI := reflective_products i
use Limits.prod X Y
constructor
... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Hopf_ | {
"line": 207,
"column": 28
} | {
"line": 207,
"column": 61
} | [
{
"pp": "case a.a.a.a.a.a.a.a.a.a\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\ninst✝² : MonoidalCategory C\ninst✝¹ : BraidedCategory C\nA : C\ninst✝ : HopfObj A\n| A ◁ (A ◁ 𝒮 ▷ A ≫ (α_ A A A).inv)",
"usedConstants": [
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryS... | associator_inv_naturality_middle, | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.CategoryTheory.Monoidal.Hopf_ | {
"line": 235,
"column": 4
} | {
"line": 235,
"column": 33
} | [
{
"pp": "case a.a.a.a.a.a\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\ninst✝² : MonoidalCategory C\ninst✝¹ : BraidedCategory C\nA : C\ninst✝ : HopfObj A\n| A ◁ (ε ≫ η) ▷ A",
"usedConstants": [
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Qu... | simp only [comp_whiskerRight] | Lean.Elab.Tactic.Conv.evalSimp | Lean.Parser.Tactic.Conv.simp |
Mathlib.CategoryTheory.Monoidal.Hopf_ | {
"line": 350,
"column": 4
} | {
"line": 350,
"column": 33
} | [
{
"pp": "case a.a.a.a.a.a.a.a.a.a.a\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\ninst✝² : MonoidalCategory C\ninst✝¹ : BraidedCategory C\nA : C\ninst✝ : HopfObj A\n| ((α_ A A A).hom ≫ A ◁ μ ≫ μ) ▷ A",
"usedConstants": [
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.Category... | simp only [comp_whiskerRight] | Lean.Elab.Tactic.Conv.evalSimp | Lean.Parser.Tactic.Conv.simp |
Mathlib.CategoryTheory.Monoidal.Hopf_ | {
"line": 382,
"column": 4
} | {
"line": 382,
"column": 33
} | [
{
"pp": "case a.a.a.a.a.a\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\ninst✝² : MonoidalCategory C\ninst✝¹ : BraidedCategory C\nA : C\ninst✝ : HopfObj A\n| A ◁ (ε ≫ η) ▷ A",
"usedConstants": [
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Qu... | simp only [comp_whiskerRight] | Lean.Elab.Tactic.Conv.evalSimp | Lean.Parser.Tactic.Conv.simp |
Mathlib.CategoryTheory.Monoidal.Hopf_ | {
"line": 411,
"column": 4
} | {
"line": 411,
"column": 33
} | [
{
"pp": "case a.a\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\ninst✝² : MonoidalCategory C\ninst✝¹ : BraidedCategory C\nA : C\ninst✝ : HopfObj A\n| (ε ≫ η) ▷ A",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.HopfObj.toBimonObj",
"CategoryTh... | simp only [comp_whiskerRight] | Lean.Elab.Tactic.Conv.evalSimp | Lean.Parser.Tactic.Conv.simp |
Mathlib.CategoryTheory.Monoidal.Hopf_ | {
"line": 417,
"column": 2
} | {
"line": 418,
"column": 31
} | [
{
"pp": "C : Type u₁\ninst✝³ : Category.{v₁, u₁} C\ninst✝² : MonoidalCategory C\ninst✝¹ : BraidedCategory C\nA : C\ninst✝ : HopfObj A\n⊢ ((ε ⊗ₘ ε) ≫ η ▷ 𝟙_ C) ≫ (ρ_ A).hom = (ε ⊗ₘ ε) ≫ (λ_ (𝟙_ C)).hom ≫ η",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Cat... | slice_lhs 2 3 =>
rw [rightUnitor_naturality] | Mathlib.Tactic.Slice._aux_Mathlib_Tactic_CategoryTheory_Slice___macroRules_Mathlib_Tactic_Slice_sliceLHS_1 | Mathlib.Tactic.Slice.sliceLHS |
Mathlib.CategoryTheory.Monoidal.Hopf_ | {
"line": 435,
"column": 2
} | {
"line": 441,
"column": 25
} | [
{
"pp": "case hac\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\ninst✝² : MonoidalCategory C\ninst✝¹ : BraidedCategory C\nA : C\ninst✝ : HopfObj A\n⊢ μ * (𝒮 ⊗ₘ 𝒮) ≫ (β_ A A).hom ≫ μ = 1",
"usedConstants": [
"CategoryTheory.ComonObj.comul",
"Eq.mpr",
"CategoryTheory.Category.assoc",
"M... | · rw [Conv.mul_eq, Conv.one_eq]
simp only [Comon.tensorObj_comul, whiskerRight_tensor,
BraidedCategory.braiding_naturality_assoc, whiskerLeft_comp, Category.assoc,
Comon.tensorObj_counit]
simp only [tensorμ]
simp only [Category.assoc, pentagon_hom_inv_inv_inv_inv_assoc]
exact mul_antipode₂ A | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.CategoryTheory.MorphismProperty.Ind | {
"line": 149,
"column": 6
} | {
"line": 150,
"column": 47
} | [
{
"pp": "case refine_1\nC : Type u\ninst✝¹ : Category.{v, u} C\nP : MorphismProperty C\nH✝ : P ≤ isFinitelyPresentable C\nX Y : C\nf : X ⟶ Y\ninst✝ : IsFinitelyAccessibleCategory (Under X)\nH : ∀ {Z : Under X} (g : Z ⟶ CategoryTheory.Under.mk f) [IsFinitelyPresentable Z], ∃ W u v, u ≫ v = g ∧ P.underObj W\nZ : ... | obtain ⟨W, u, v, huv, hW⟩ := H (CategoryTheory.Under.homMk (U := CategoryTheory.Under.mk p)
(V := CategoryTheory.Under.mk f) g hpg) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.CategoryTheory.Presentable.OrthogonalReflection | {
"line": 92,
"column": 6
} | {
"line": 92,
"column": 53
} | [
{
"pp": "case refine_2\nC : Type u\ninst✝⁴ : Category.{v, u} C\nW : MorphismProperty C\nJ : Type u'\ninst✝³ : Category.{v', u'} J\ninst✝² : EssentiallySmall.{w, v', u'} J\nκ : Cardinal.{w}\ninst✝¹ : Fact κ.IsRegular\ninst✝ : IsCardinalFiltered J κ\nhW : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f → IsCardinalPresentable X κ ∧... | obtain ⟨g, rfl⟩ := (p.prop_diag_obj j _ hf).2 g | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.CategoryTheory.Preadditive.Mat | {
"line": 193,
"column": 14
} | {
"line": 207,
"column": 19
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\ninst✝ : Preadditive C\nn : ℕ\nf : Fin n → Mat_ C\nj j' : Fin n\n⊢ ((fun x y ↦ if h : y.fst = j then if h' : h ▸ y.snd = x then eqToHom ⋯ else 0 else 0) ≫ fun x y ↦\n if h : x.fst = j' then if h' : h ▸ x.snd = y then eqToHom ⋯ else 0 else 0) =\n if h : ... | ext x y
dsimp
simp_rw [dite_comp, comp_dite]
simp only [ite_self, dite_eq_ite, Limits.comp_zero, Limits.zero_comp,
eqToHom_trans]
rw [← Finset.univ_sigma_univ, Finset.sum_sigma]
dsimp +instances
simp only [if_true, Finse... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Preadditive.Mat | {
"line": 193,
"column": 14
} | {
"line": 207,
"column": 19
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\ninst✝ : Preadditive C\nn : ℕ\nf : Fin n → Mat_ C\nj j' : Fin n\n⊢ ((fun x y ↦ if h : y.fst = j then if h' : h ▸ y.snd = x then eqToHom ⋯ else 0 else 0) ≫ fun x y ↦\n if h : x.fst = j' then if h' : h ▸ x.snd = y then eqToHom ⋯ else 0 else 0) =\n if h : ... | ext x y
dsimp
simp_rw [dite_comp, comp_dite]
simp only [ite_self, dite_eq_ite, Limits.comp_zero, Limits.zero_comp,
eqToHom_trans]
rw [← Finset.univ_sigma_univ, Finset.sum_sigma]
dsimp +instances
simp only [if_true, Finse... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Presentable.Directed | {
"line": 408,
"column": 71
} | {
"line": 408,
"column": 82
} | [
{
"pp": "J : Type w\ninst✝² : SmallCategory J\nκ : Cardinal.{w}\ninst✝¹ : Fact κ.IsRegular\ninst✝ : IsCardinalFiltered J κ\nhJ : ∀ (e : J), ∃ m x, IsEmpty (m ⟶ e)\nι : Type w\nD : ι → DiagramWithUniqueTerminal J κ\nhι : HasCardinalLT ι κ\nm : J\nu : (i : ι) → (D i).top ⟶ m\nhm₀ : ∀ (i : ι), IsEmpty (m ⟶ (D i).t... | by simp [φ] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Sites.Coherent.Comparison | {
"line": 70,
"column": 4
} | {
"line": 70,
"column": 18
} | [
{
"pp": "case h.h.h.refine_1.of\nC : Type u_1\ninst✝² : Category.{v_1, u_1} C\ninst✝¹ : Preregular C\ninst✝ : FinitaryPreExtensive C\nB : C\nS : Sieve B\nY : C\nT : Presieve Y\nhT : T ∈ (extensiveCoverage C ⊔ regularCoverage C).coverings Y\n⊢ generate T ∈ (coherentTopology C) Y",
"usedConstants": [
"C... | | of Y T hT => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.CategoryTheory.Sites.Coherent.Comparison | {
"line": 79,
"column": 4
} | {
"line": 79,
"column": 18
} | [
{
"pp": "case h.h.h.refine_2.of\nC : Type u_1\ninst✝² : Category.{v_1, u_1} C\ninst✝¹ : Preregular C\ninst✝ : FinitaryPreExtensive C\nB : C\nS : Sieve B\nY : C\nT : Presieve Y\nhT : T ∈ (coherentCoverage C).coverings Y\n⊢ generate T ∈ (extensiveCoverage C ⊔ regularCoverage C).toGrothendieck Y",
"usedConstan... | | of Y T hT => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.CategoryTheory.Sites.Coherent.LocallySurjective | {
"line": 121,
"column": 4
} | {
"line": 121,
"column": 72
} | [
{
"pp": "C : Type u_1\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Preregular C\ninst✝² : FinitaryPreExtensive C\nF G : Cᵒᵖ ⥤ Type w\nf : F ⟶ G\ninst✝¹ : PreservesFiniteProducts F\ninst✝ : PreservesFiniteProducts G\nU✝ : C\ny : ToType (G.obj (op U✝))\nα : Type\nw✝ : Finite α\nZ : α → C\nπ : (a : α) → Z a ⟶ U✝\nh :... | have := preservesLimitsOfShape_of_equiv (Discrete.opposite α).symm G | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | {
"line": 91,
"column": 6
} | {
"line": 91,
"column": 63
} | [
{
"pp": "case h.h.h\nC : Type u_1\nD : Type u_2\ninst✝⁷ : Category.{v_1, u_1} C\ninst✝⁶ : Category.{v_2, u_2} D\nF : C ⥤ D\ninst✝⁵ : F.PreservesFiniteEffectiveEpiFamilies\ninst✝⁴ : F.ReflectsFiniteEffectiveEpiFamilies\ninst✝³ : F.Full\ninst✝² : F.Faithful\ninst✝¹ : F.EffectivelyEnough\ninst✝ : Precoherent D\nX ... | ← coherentTopology.mem_sieves_iff_hasEffectiveEpiFamily S | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | {
"line": 68,
"column": 2
} | {
"line": 72,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nS : C\nA : Type u_1\ninst✝ : Category.{v_1, u_1} A\nE F : PreOneHypercover S\nf g : E.Hom F\nH : Homotopy f g\nP : Cᵒᵖ ⥤ A\nc : Multifork (E.multicospanIndex P)\nhc : IsLimit c\nd : Multifork (F.multicospanIndex P)\n⊢ f.mapMultiforkOfIsLimit P hc d = g.mapMultifo... | refine Multifork.IsLimit.hom_ext hc fun a ↦ ?_
have heq := d.condition ⟨⟨(f.s₀ a), (g.s₀ a)⟩, H.H a⟩
simp only [multicospanIndex_right, multicospanShape_fst, multicospanIndex_left,
multicospanIndex_fst, multicospanShape_snd, multicospanIndex_snd] at heq
simp [-Homotopy.wl, -Homotopy.wr, ← H.wl, ← H.wr, reasso... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | {
"line": 68,
"column": 2
} | {
"line": 72,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nS : C\nA : Type u_1\ninst✝ : Category.{v_1, u_1} A\nE F : PreOneHypercover S\nf g : E.Hom F\nH : Homotopy f g\nP : Cᵒᵖ ⥤ A\nc : Multifork (E.multicospanIndex P)\nhc : IsLimit c\nd : Multifork (F.multicospanIndex P)\n⊢ f.mapMultiforkOfIsLimit P hc d = g.mapMultifo... | refine Multifork.IsLimit.hom_ext hc fun a ↦ ?_
have heq := d.condition ⟨⟨(f.s₀ a), (g.s₀ a)⟩, H.H a⟩
simp only [multicospanIndex_right, multicospanShape_fst, multicospanIndex_left,
multicospanIndex_fst, multicospanShape_snd, multicospanIndex_snd] at heq
simp [-Homotopy.wl, -Homotopy.wr, ← H.wl, ← H.wr, reasso... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Sites.Point.Skyscraper | {
"line": 164,
"column": 4
} | {
"line": 164,
"column": 56
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nJ : GrothendieckTopology C\nΦ : J.Point\nA : Type u'\ninst✝¹ : Category.{v', u'} A\ninst✝ : HasProducts A\nM : A\nX : C\nR : Sieve X\nhR : R ∈ J X\ns : Cone (R.arrows.diagram.op ⋙ Φ.skyscraperPresheaf M)\nx : Φ.fiber.obj X\nY₁ : C\nf₁ : Y₁ ⟶ X\nhf₁ : R.arrows f₁\... | obtain ⟨z, q₁, q₂, fac⟩ := IsCofiltered.cospan α₁ α₂ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.CategoryTheory.Sites.Point.Conservative | {
"line": 228,
"column": 10
} | {
"line": 228,
"column": 93
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nJ : GrothendieckTopology C\nP : ObjectProperty J.Point\ninst✝¹ : LocallySmall.{w, v, u} C\nhP :\n ∀ ⦃X : C⦄ (S : Sieve X),\n (∀ (Φ : P.FullSubcategory) (x : Φ.obj.fiber.obj X),\n ∃ Y g, ∃ (_ : S.arrows g), ∃ y, (ConcreteCategory.hom (Φ.obj.fiber.map g)... | ← Φ.obj.presheafFiber_map_shrinkYoneda_map_shrinkYonedaCompPresheafFiberIso_inv_app | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Sites.Point.Presheaf | {
"line": 96,
"column": 8
} | {
"line": 96,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : LocallySmall.{w, v, u} C\nX : C\nS : Sieve X\nhS :\n ∀ (Φ : (pointsBot C).FullSubcategory) (x : Φ.obj.fiber.obj X),\n ∃ Y g, ∃ (_ : S.arrows g), ∃ y, (ConcreteCategory.hom (Φ.obj.fiber.map g)) y = x\nY : C\na : Y ⟶ X\nha : S.arrows a\nb : X ⟶ Y\nhb :\... | rw [← hb, shrinkYoneda_map_app_shrinkYonedaObjObjEquiv_symm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Sites.Point.Presheaf | {
"line": 96,
"column": 8
} | {
"line": 96,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : LocallySmall.{w, v, u} C\nX : C\nS : Sieve X\nhS :\n ∀ (Φ : (pointsBot C).FullSubcategory) (x : Φ.obj.fiber.obj X),\n ∃ Y g, ∃ (_ : S.arrows g), ∃ y, (ConcreteCategory.hom (Φ.obj.fiber.map g)) y = x\nY : C\na : Y ⟶ X\nha : S.arrows a\nb : X ⟶ Y\nhb :\... | rw [← hb, shrinkYoneda_map_app_shrinkYonedaObjObjEquiv_symm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Sites.Point.Presheaf | {
"line": 96,
"column": 8
} | {
"line": 96,
"column": 68
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : LocallySmall.{w, v, u} C\nX : C\nS : Sieve X\nhS :\n ∀ (Φ : (pointsBot C).FullSubcategory) (x : Φ.obj.fiber.obj X),\n ∃ Y g, ∃ (_ : S.arrows g), ∃ y, (ConcreteCategory.hom (Φ.obj.fiber.map g)) y = x\nY : C\na : Y ⟶ X\nha : S.arrows a\nb : X ⟶ Y\nhb :\... | rw [← hb, shrinkYoneda_map_app_shrinkYonedaObjObjEquiv_symm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Sites.Descent.DescentData | {
"line": 223,
"column": 8
} | {
"line": 223,
"column": 65
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nF : Pseudofunctor (LocallyDiscrete Cᵒᵖ) Cat\nι : Type t\nS : C\nX : ι → C\nf : (i : ι) → X i ⟶ S\nS' : C\np : S' ⟶ S\nι' : Type t'\nX' : ι' → C\nf' : (j : ι') → X' j ⟶ S'\nα : ι' → ι\np' : (j : ι') → X' j ⟶ X (α j)\nw : ∀ (j : ι'), p' j ≫ f (α j) = f' j ≫ p\nD : F... | pullFunctorObjHom_eq _ _ _ _ _ _ _ _ rfl rfl rfl rfl rfl, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Sites.Descent.DescentData | {
"line": 305,
"column": 17
} | {
"line": 305,
"column": 19
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nF : Pseudofunctor (LocallyDiscrete Cᵒᵖ) Cat\nι : Type t\nS : C\nX : ι → C\nf : (i : ι) → X i ⟶ S\nS' : C\np : S' ⟶ S\nι' : Type t'\nX' : ι' → C\nf' : (j : ι') → X' j ⟶ S'\nα : ι' → ι\np' : (j : ι') → X' j ⟶ X (α j)\nw : ∀ (j : ι'), p' j ≫ f (α j) = f' j ≫ p\nβ : ι... | j₂ | Lean.Elab.Tactic.evalIntro | ident |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.