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.Analysis.Real.Pi.Bounds | {
"line": 71,
"column": 2
} | {
"line": 76,
"column": 18
} | [
{
"pp": "c d a b n : ℕ\nz : ℝ\nhz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z\nhb : 0 < b\nhd : 0 < d\nh : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b\n⊢ (↑a / ↑b).sqrtTwoAddSeries (n + 1) ≤ z",
"usedConstants": [
"Nat.cast_mul._simp_1",
"Iff.mpr",
"Real.instIsOrderedRing",
"Eq.mpr",
"GroupWithZero... | refine le_trans ?_ hz; rw [sqrtTwoAddSeries_succ]; apply sqrtTwoAddSeries_monotone_left
have hb' : 0 < (b : ℝ) := Nat.cast_pos.2 hb
have hd' : 0 < (d : ℝ) := Nat.cast_pos.2 hd
rw [sqrt_le_left (div_nonneg c.cast_nonneg d.cast_nonneg), div_pow,
add_div_eq_mul_add_div _ _ (ne_of_gt hb'), div_le_div_iff₀ hb' (po... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Rat.Sqrt | {
"line": 35,
"column": 21
} | {
"line": 35,
"column": 57
} | [
{
"pp": "x : ℚ\nx✝ : ∃ q, q * q = x\nn : ℚ\nhn : n * n = x\n⊢ sqrt x * sqrt x = x",
"usedConstants": [
"Eq.mpr",
"Rat.instMul",
"HMul.hMul",
"AddGroupWithOne.toAddGroup",
"abs",
"congrArg",
"Rat",
"Rat.linearOrder",
"DistribLattice.toLattice",
"id"... | rw [← hn, sqrt_eq, abs_mul_abs_self] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Rat.Sqrt | {
"line": 35,
"column": 21
} | {
"line": 35,
"column": 57
} | [
{
"pp": "x : ℚ\nx✝ : ∃ q, q * q = x\nn : ℚ\nhn : n * n = x\n⊢ sqrt x * sqrt x = x",
"usedConstants": [
"Eq.mpr",
"Rat.instMul",
"HMul.hMul",
"AddGroupWithOne.toAddGroup",
"abs",
"congrArg",
"Rat",
"Rat.linearOrder",
"DistribLattice.toLattice",
"id"... | rw [← hn, sqrt_eq, abs_mul_abs_self] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Rat.Sqrt | {
"line": 35,
"column": 21
} | {
"line": 35,
"column": 57
} | [
{
"pp": "x : ℚ\nx✝ : ∃ q, q * q = x\nn : ℚ\nhn : n * n = x\n⊢ sqrt x * sqrt x = x",
"usedConstants": [
"Eq.mpr",
"Rat.instMul",
"HMul.hMul",
"AddGroupWithOne.toAddGroup",
"abs",
"congrArg",
"Rat",
"Rat.linearOrder",
"DistribLattice.toLattice",
"id"... | rw [← hn, sqrt_eq, abs_mul_abs_self] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Rat.Sqrt | {
"line": 50,
"column": 58
} | {
"line": 50,
"column": 74
} | [
{
"pp": "n : ℕ\n⊢ ↑↑n.sqrt = ↑n.sqrt",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.cast_natCast",
"congrArg",
"Rat",
"AddGroupWithOne.toAddMonoidWithOne",
"Rat.instIntCast",
"id",
"AddMonoidWithOne.toNatCast",
"Nat.sqrt",
"Int",
"AddG... | Int.cast_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Analysis.SpecialFunctions.Artanh | {
"line": 57,
"column": 60
} | {
"line": 57,
"column": 78
} | [
{
"pp": "x : ℝ\nhx : x ∈ Icc (-1) 1\n⊢ log ((1 + x) / (1 - x)) / 2 = 1 / 2 * log ((1 + x) / (1 - x))",
"usedConstants": [
"Eq.mpr",
"Real",
"instHDiv",
"InvOneClass.toOne",
"HMul.hMul",
"GroupWithZero.toDivInvMonoid",
"DivisionCommMonoid.toDivisionMonoid",
"Di... | one_div_mul_eq_div | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Analysis.Real.Pi.Irrational | {
"line": 220,
"column": 4
} | {
"line": 220,
"column": 31
} | [
{
"pp": "case inl.inr\np : ℤ[X]\na : ℤ\nk : ℕ\nhp : p.natDegree ≤ k\nhk : k > 0\n⊢ ∃ z, eval₂ (Int.castRingHom ℝ) (↑a / ↑0) p * ↑0 ^ k = ↑z",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast",
"GroupWithZero.toMonoidWithZero",
"RingHom.instRingHomClass",
"False",
... | exact ⟨0, by simp [hk.ne']⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Analysis.Real.Pi.Irrational | {
"line": 289,
"column": 2
} | {
"line": 294,
"column": 75
} | [
{
"pp": "h' : ¬Irrational (π / 2)\na : ℤ\nb : ℕ\nhb : 0 < b\nh : π / 2 = ↑a / ↑b\nha : 0 < ↑a\nk : ∀ (n : ℕ), 0 < ↑a ^ (2 * n + 1) / ↑n !\n⊢ False",
"usedConstants": [
"Iff.mpr",
"Real.instIsOrderedRing",
"Int.cast",
"GroupWithZero.toMonoidWithZero",
"pow_pos",
"Real.part... | have j : ∀ᶠ n : ℕ in atTop, (a : ℝ) ^ (2 * n + 1) / n ! * I n (π / 2) < 1 := by
have := (tendsto_pow_div_factorial_at_top_aux a).eventually_lt_const
(show (0 : ℝ) < 1 / 2 by simp)
filter_upwards [this] with n hn
rw [lt_div_iff₀ (zero_lt_two : (0 : ℝ) < 2)] at hn
exact hn.trans_le' (mul_le_mul_of_n... | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Analysis.SpecialFunctions.Gamma.Deligne | {
"line": 68,
"column": 4
} | {
"line": 68,
"column": 21
} | [
{
"pp": "case ha\ns : ℂ\nhs : 0 < s.re\n⊢ ↑π ^ (-s / 2) ≠ 0",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"Real",
"instHDiv",
"Real.pi",
"GroupWithZero.toDivInvMonoid",
"Real.instZero",
"congrArg",
"neg_eq_zero._simp_1",
"AddGroup... | simp [pi_ne_zero] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Analysis.SpecialFunctions.Gamma.Deligne | {
"line": 68,
"column": 4
} | {
"line": 68,
"column": 21
} | [
{
"pp": "case ha\ns : ℂ\nhs : 0 < s.re\n⊢ ↑π ^ (-s / 2) ≠ 0",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"Real",
"instHDiv",
"Real.pi",
"GroupWithZero.toDivInvMonoid",
"Real.instZero",
"congrArg",
"neg_eq_zero._simp_1",
"AddGroup... | simp [pi_ne_zero] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Analysis.SpecialFunctions.Gamma.Deligne | {
"line": 68,
"column": 4
} | {
"line": 68,
"column": 21
} | [
{
"pp": "case ha\ns : ℂ\nhs : 0 < s.re\n⊢ ↑π ^ (-s / 2) ≠ 0",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"Real",
"instHDiv",
"Real.pi",
"GroupWithZero.toDivInvMonoid",
"Real.instZero",
"congrArg",
"neg_eq_zero._simp_1",
"AddGroup... | simp [pi_ne_zero] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Analysis.SpecialFunctions.Gamma.Deligne | {
"line": 90,
"column": 49
} | {
"line": 90,
"column": 66
} | [
{
"pp": "s : ℂ\n⊢ ↑π ^ (-s / 2) ≠ 0",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"Real",
"instHDiv",
"Real.pi",
"GroupWithZero.toDivInvMonoid",
"Real.instZero",
"congrArg",
"neg_eq_zero._simp_1",
"Complex.instNormedField",
... | simp [pi_ne_zero] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Analysis.SpecialFunctions.Gamma.Deligne | {
"line": 90,
"column": 49
} | {
"line": 90,
"column": 66
} | [
{
"pp": "s : ℂ\n⊢ ↑π ^ (-s / 2) ≠ 0",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"Real",
"instHDiv",
"Real.pi",
"GroupWithZero.toDivInvMonoid",
"Real.instZero",
"congrArg",
"neg_eq_zero._simp_1",
"Complex.instNormedField",
... | simp [pi_ne_zero] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Analysis.SpecialFunctions.Gamma.Deligne | {
"line": 90,
"column": 49
} | {
"line": 90,
"column": 66
} | [
{
"pp": "s : ℂ\n⊢ ↑π ^ (-s / 2) ≠ 0",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"Real",
"instHDiv",
"Real.pi",
"GroupWithZero.toDivInvMonoid",
"Real.instZero",
"congrArg",
"neg_eq_zero._simp_1",
"Complex.instNormedField",
... | simp [pi_ne_zero] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Analysis.SpecialFunctions.Gamma.Deligne | {
"line": 98,
"column": 32
} | {
"line": 98,
"column": 65
} | [
{
"pp": "⊢ Tendsto (fun z ↦ z / 2) (𝓝[≠] 0) (𝓝 0) ∧ ∀ᶠ (n : ℂ) in 𝓝[≠] 0, n / 2 ∈ {0}ᶜ",
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NormedCommRing.toSeminormedCommRing",
"instHDiv",
"congrArg",
"Compl.compl",
"nhdsWithin",
"Filter.Event... | (by simp : 𝓝 (0 : ℂ) = 𝓝 (0 / 2)) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.RingInverseOrder | {
"line": 44,
"column": 4
} | {
"line": 45,
"column": 45
} | [
{
"pp": "A : Type u_1\ninst✝² : CStarAlgebra A\ninst✝¹ : PartialOrder A\ninst✝ : StarOrderedRing A\nx : A\nxpos : IsStrictlyPositive x\ny : A\nypos : IsStrictlyPositive y\na b : ℝ\nha : 0 ≤ a\nhb : 0 ≤ b\nhab : a + b = 1\nz : A := (conjSqrt x⁻¹ʳ) y\nzpos : IsStrictlyPositive z\nxinvpos : IsStrictlyPositive x⁻¹ʳ... | rw [← cfc_smul_id (R := ℝ) (S := ℝ) b z, ← Algebra.algebraMap_eq_smul_one,
← cfc_const_add a (fun r => b • r) z] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Analysis.SpecialFunctions.Log.Base | {
"line": 299,
"column": 86
} | {
"line": 300,
"column": 100
} | [
{
"pp": "b x y : ℝ\nb_pos : 0 < b\nb_lt_one : b < 1\nhx : 0 < x\n⊢ logb b x < y ↔ b ^ y < x",
"usedConstants": [
"Eq.mpr",
"Real.instPow",
"Real",
"congrArg",
"Iff.rfl",
"Real.instLT",
"id",
"Real.rpow_logb",
"Real.logb",
"Iff",
"HPow.hPow",
... | by
rw [← rpow_lt_rpow_left_iff_of_base_lt_one b_pos b_lt_one, rpow_logb b_pos (b_ne_one b_lt_one) hx] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Analysis.SpecialFunctions.Log.Base | {
"line": 309,
"column": 6
} | {
"line": 309,
"column": 20
} | [
{
"pp": "b x : ℝ\nb_pos : 0 < b\nb_lt_one : b < 1\nhx : 0 < x\n⊢ 0 < logb b x ↔ x < 1",
"usedConstants": [
"Eq.mpr",
"Real.logb_one",
"Real",
"Real.instZero",
"congrArg",
"Real.instLT",
"id",
"Real.instOne",
"Real.logb",
"Iff",
"LT.lt",
... | ← @logb_one b, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Analysis.SpecialFunctions.Log.Base | {
"line": 316,
"column": 6
} | {
"line": 316,
"column": 20
} | [
{
"pp": "b x : ℝ\nb_pos : 0 < b\nb_lt_one : b < 1\nh : 0 < x\n⊢ logb b x < 0 ↔ 1 < x",
"usedConstants": [
"Eq.mpr",
"Real.logb_one",
"Real",
"Real.instZero",
"congrArg",
"Real.instLT",
"id",
"Real.instOne",
"Real.logb",
"Iff",
"LT.lt",
... | ← @logb_one b, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Analysis.SpecialFunctions.Log.Base | {
"line": 371,
"column": 10
} | {
"line": 371,
"column": 41
} | [
{
"pp": "case pos.a\nb : ℕ\nr : ℝ\nhr✝ : 0 ≤ r\nhr : 0 < r\nhb : 1 < b\nhb1' : 1 < ↑b\n⊢ ⌊logb (↑b) r⌋ ≤ Int.log b r",
"usedConstants": [
"Real.instIsOrderedRing",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Real",
"GroupWithZero.toDivInvMonoid",
"instConditiona... | ← Int.zpow_le_iff_le_log hb hr, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Analysis.SpecialFunctions.Log.Base | {
"line": 423,
"column": 68
} | {
"line": 423,
"column": 84
} | [
{
"pp": "a b : ℕ\n⊢ ↑(Nat.log b a) ≤ ↑↑(Nat.log b a)",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.cast_natCast",
"Real",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
"Preorder.toLE",
"id",
"AddMonoidWithOne.toNatCast",
"Real.instRing",
... | Int.cast_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.MeasureTheory.Constructions.HaarToSphere | {
"line": 67,
"column": 61
} | {
"line": 71,
"column": 98
} | [
{
"pp": "E : Type u_1\ninst✝³ : NormedAddCommGroup E\ninst✝² : NormedSpace ℝ E\ninst✝¹ : MeasurableSpace E\nμ : Measure E\ninst✝ : BorelSpace E\ns : Set ↑(sphere 0 1)\nhs : MeasurableSet s\n⊢ μ.toSphere s = ↑(dim E) * μ (Ioo 0 1 • Subtype.val '' s)",
"usedConstants": [
"Set.instSProd",
"Eq.mpr",... | by
rw [toSphere, smul_apply, fst_apply hs, restrict_apply (measurable_fst hs),
((MeasurableEmbedding.subtype_coe (measurableSet_singleton _).compl).comp
(Homeomorph.measurableEmbedding _)).comap_apply,
image_comp, Homeomorph.image_symm, univ_prod, ← Set.prod_eq, nsmul_eq_mul, toSphere_apply_aux] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Analysis.SpecialFunctions.Sigmoid | {
"line": 138,
"column": 2
} | {
"line": 140,
"column": 12
} | [
{
"pp": "x : ℝ\n⊢ HasDerivAt sigmoid (x.sigmoid * (1 - x.sigmoid)) x",
"usedConstants": [
"IsModuleTopology.toContinuousSMul",
"NormedCommRing.toNormedRing",
"Real.instIsOrderedRing",
"Mathlib.Tactic.FieldSimp.zpow'_one",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
... | convert! (hasDerivAt_neg' x |>.exp.const_add 1 |>.inv <| by positivity) using 1
rw [← sigmoid_neg, ← sigmoid_mul_rexp_neg x, sigmoid_def]
field [sq] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Analysis.SpecialFunctions.Sigmoid | {
"line": 138,
"column": 2
} | {
"line": 140,
"column": 12
} | [
{
"pp": "x : ℝ\n⊢ HasDerivAt sigmoid (x.sigmoid * (1 - x.sigmoid)) x",
"usedConstants": [
"IsModuleTopology.toContinuousSMul",
"NormedCommRing.toNormedRing",
"Real.instIsOrderedRing",
"Mathlib.Tactic.FieldSimp.zpow'_one",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
... | convert! (hasDerivAt_neg' x |>.exp.const_add 1 |>.inv <| by positivity) using 1
rw [← sigmoid_neg, ← sigmoid_mul_rexp_neg x, sigmoid_def]
field [sq] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.MeasureTheory.Constructions.HaarToSphere | {
"line": 267,
"column": 4
} | {
"line": 267,
"column": 26
} | [
{
"pp": "E : Type u_1\ninst✝⁸ : NormedAddCommGroup E\ninst✝⁷ : NormedSpace ℝ E\ninst✝⁶ : MeasurableSpace E\nF : Type u_2\ninst✝⁵ : NormedAddCommGroup F\ninst✝⁴ : NormedSpace ℝ F\ninst✝³ : Nontrivial E\nμ : Measure E\ninst✝² : FiniteDimensional ℝ E\ninst✝¹ : BorelSpace E\ninst✝ : μ.IsAddHaarMeasure\nf : ℝ → F\nt... | rintro ⟨x, hx : 0 < x⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.MeasureTheory.Constructions.HaarToSphere | {
"line": 285,
"column": 8
} | {
"line": 285,
"column": 50
} | [
{
"pp": "E : Type u_1\ninst✝⁸ : NormedAddCommGroup E\ninst✝⁷ : NormedSpace ℝ E\ninst✝⁶ : MeasurableSpace E\nF : Type u_2\ninst✝⁵ : NormedAddCommGroup F\ninst✝⁴ : NormedSpace ℝ F\ninst✝³ : Nontrivial E\nμ : Measure E\ninst✝² : FiniteDimensional ℝ E\ninst✝¹ : BorelSpace E\ninst✝ : μ.IsAddHaarMeasure\nf : ℝ → F\nr... | integrableOn_congr_fun _ measurableSet_Ioi | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.MeasureTheory.Constructions.HaarToSphere | {
"line": 301,
"column": 10
} | {
"line": 301,
"column": 83
} | [
{
"pp": "E : Type u_1\ninst✝⁸ : NormedAddCommGroup E\ninst✝⁷ : NormedSpace ℝ E\ninst✝⁶ : MeasurableSpace E\nF : Type u_2\ninst✝⁵ : NormedAddCommGroup F\ninst✝⁴ : NormedSpace ℝ F\ninst✝³ : Nontrivial E\nμ : Measure E\ninst✝² : FiniteDimensional ℝ E\ninst✝¹ : BorelSpace E\ninst✝ : μ.IsAddHaarMeasure\nf : ℝ → F\n⊢... | integral_subtype_comap (measurableSet_singleton _).compl fun x ↦ f (‖x‖), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.MeasureTheory.Integral.IntervalIntegral.ContDiff | {
"line": 39,
"column": 2
} | {
"line": 42,
"column": 32
} | [
{
"pp": "case inr.hderiv\nE : Type u_3\ninst✝² : NormedAddCommGroup E\ninst✝¹ : NormedSpace ℝ E\nf : ℝ → E\na b : ℝ\ninst✝ : CompleteSpace E\nh : ContDiffOn ℝ 1 f (Icc a b)\nhab : a ≤ b\nh'ab : a < b\n⊢ ∀ x ∈ Ioo a b, HasDerivAt f (deriv f x) x",
"usedConstants": [
"InnerProductSpace.toNormedSpace",
... | · intro x hx
apply DifferentiableAt.hasDerivAt
apply ((h x ⟨hx.1.le, hx.2.le⟩).differentiableWithinAt one_ne_zero).differentiableAt
exact Icc_mem_nhds hx.1 hx.2 | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.NumberTheory.Niven | {
"line": 59,
"column": 2
} | {
"line": 59,
"column": 55
} | [
{
"pp": "q : ℚ\n⊢ IsIntegral ℤ (cexp (↑q * ↑π * I))",
"usedConstants": [
"Nat.instIsOrderedAddMonoid",
"Real.pi",
"HMul.hMul",
"Nat.instAtLeastTwoHAddOfNat",
"Nat.instZeroLEOneClass",
"Rat.den",
"Complex.instMul",
"IsIntegral.of_pow",
"Nat.mul_pos",
... | refine .of_pow (Nat.mul_pos zero_lt_two q.den_pos) ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | {
"line": 135,
"column": 63
} | {
"line": 135,
"column": 81
} | [
{
"pp": "z : ℍ\nx : Fin 2 → ℤ\nhx : x ≠ 0\nhn0 : ‖x‖ ≠ 0\nh11 : ↑(x 0) * ↑z + ↑(x 1) = (↑(x 0) / ↑‖x‖ * ↑z + ↑(x 1) / ↑‖x‖) * ↑‖x‖\n⊢ r z * ↑(max (x 0).natAbs (x 1).natAbs) ≤ ‖↑(x 0) / ↑‖x‖ * ↑z + ↑(x 1) / ↑‖x‖‖ * ‖x‖",
"usedConstants": [
"NormedCommRing.toNormedRing",
"Norm.norm",
"Int.ca... | norm_eq_max_natAbs | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Algebra.InfiniteSum.TsumUniformlyOn | {
"line": 113,
"column": 25
} | {
"line": 113,
"column": 54
} | [
{
"pp": "ι : Type u_1\n𝕜 : Type u_2\nF : Type u_3\ninst✝³ : NontriviallyNormedField 𝕜\ninst✝² : IsRCLikeNormedField 𝕜\ninst✝¹ : NormedAddCommGroup F\ninst✝ : NormedSpace 𝕜 F\ns : Set 𝕜\nf : ι → 𝕜 → F\nhs : IsOpen[PseudoMetricSpace.toUniformSpace.toTopologicalSpace] s\nhsum : ∀ t ∈ s, Summable fun n ↦ f n ... | rw [iteratedDerivWithin_succ] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.Algebra.InfiniteSum.TsumUniformlyOn | {
"line": 113,
"column": 25
} | {
"line": 113,
"column": 54
} | [
{
"pp": "ι : Type u_1\n𝕜 : Type u_2\nF : Type u_3\ninst✝³ : NontriviallyNormedField 𝕜\ninst✝² : IsRCLikeNormedField 𝕜\ninst✝¹ : NormedAddCommGroup F\ninst✝ : NormedSpace 𝕜 F\ns : Set 𝕜\nf : ι → 𝕜 → F\nhs : IsOpen[PseudoMetricSpace.toUniformSpace.toTopologicalSpace] s\nhsum : ∀ t ∈ s, Summable fun n ↦ f n ... | rw [iteratedDerivWithin_succ] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Algebra.InfiniteSum.TsumUniformlyOn | {
"line": 113,
"column": 25
} | {
"line": 113,
"column": 54
} | [
{
"pp": "ι : Type u_1\n𝕜 : Type u_2\nF : Type u_3\ninst✝³ : NontriviallyNormedField 𝕜\ninst✝² : IsRCLikeNormedField 𝕜\ninst✝¹ : NormedAddCommGroup F\ninst✝ : NormedSpace 𝕜 F\ns : Set 𝕜\nf : ι → 𝕜 → F\nhs : IsOpen[PseudoMetricSpace.toUniformSpace.toTopologicalSpace] s\nhsum : ∀ t ∈ s, Summable fun n ↦ f n ... | rw [iteratedDerivWithin_succ] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.Fib.Basic | {
"line": 70,
"column": 4
} | {
"line": 71,
"column": 71
} | [
{
"pp": "case negSucc\nn : ℕ\n⊢ fib (-↑(n + 1) + 2) = (-1) ^ (n + 1 + 1) * ↑(Nat.fib (n + 1)) + fib (-↑(n + 1) + 1)",
"usedConstants": [
"neg_add_rev",
"Int.instAddCommGroup",
"Int.instAddSemigroup",
"Eq.mpr",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"Int.fib_neg_na... | simp only [Nat.cast_add, Nat.cast_one, neg_add_rev, reduceNeg, add_comm,
add_assoc, reduceAdd, add_neg_cancel_comm_assoc, fib_neg_natCast] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | {
"line": 255,
"column": 8
} | {
"line": 255,
"column": 25
} | [
{
"pp": "case mp\nn : ℕ\nhn : 2 ≤ n\nx : ℝ\nhx : deriv (fun x ↦ eval x (T ℝ ↑n)) x = 0\n⊢ ∃ k ∈ Finset.Ioo 0 n, x = cos (↑k * π / ↑n)",
"usedConstants": [
"NormedCommRing.toNormedRing",
"Polynomial.derivative",
"Polynomial.eval",
"NormedCommRing.toSeminormedCommRing",
"Real",
... | Polynomial.deriv, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | {
"line": 40,
"column": 32
} | {
"line": 40,
"column": 43
} | [
{
"pp": "z : ℂ\n⊢ cos z / ((cexp (-z * I) - cexp (z * I)) * I / 2) = (cexp (2 * I * z) + 1) / (I * (1 - cexp (2 * I * z)))",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"Complex.cos",
"congrArg",
"Nat.instAtLeastTwoHAddOfNat",
"HSub.hSub",
"Complex.c... | Complex.cos | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | {
"line": 1017,
"column": 2
} | {
"line": 1017,
"column": 22
} | [
{
"pp": "L : PeriodPair\ni : ℕ\nhi₁ : i < 7\n⊢ iteratedDeriv i (L.relation * id ^ 6) 0 = 0",
"usedConstants": [
"InnerProductSpace.toNormedSpace",
"HMul.hMul",
"Complex.instNormedAddCommGroup",
"_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.relation",
... | by_cases hi₂ : Odd i | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Analysis.SumIntegralComparisons | {
"line": 215,
"column": 6
} | {
"line": 215,
"column": 35
} | [
{
"pp": "a b : ℕ\nf g : ℝ → ℝ\nhab : a ≤ b\nhf : MonotoneOn f (Icc ↑a ↑b)\nhg : AntitoneOn g (Icc (↑a - 1) (↑b - 1))\nfpos : 0 ≤ f ↑a\ngpos : 0 ≤ g (↑b - 1)\ni : ℕ\nx : ℝ\nhx : ↑i ≤ x ∧ x < ↑i + 1\nhi : a ≤ i ∧ i < b\nI0 : ↑i ≤ ↑b - 1\n⊢ ↑a ≤ ↑i + 1 ∧ ↑i ≤ ↑b - 1",
"usedConstants": [
"Eq.mpr",
"... | exact ⟨by norm_cast; lia, I0⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Analysis.SumIntegralComparisons | {
"line": 261,
"column": 6
} | {
"line": 261,
"column": 35
} | [
{
"pp": "a b : ℕ\nf g : ℝ → ℝ\nhab : a ≤ b\nhf : AntitoneOn f (Icc ↑a ↑b)\nhg : MonotoneOn g (Icc (↑a - 1) (↑b - 1))\nfpos : 0 ≤ f ↑b\ngpos : 0 ≤ g (↑a - 1)\ni : ℕ\nx : ℝ\nhx : ↑i ≤ x ∧ x < ↑i + 1\nhi : a ≤ i ∧ i < b\nI0 : ↑i ≤ ↑b - 1\n⊢ ↑a ≤ ↑i + 1 ∧ ↑i ≤ ↑b - 1",
"usedConstants": [
"Eq.mpr",
"... | exact ⟨by norm_cast; lia, I0⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Analysis.SpecificLimits.FloorPow | {
"line": 165,
"column": 71
} | {
"line": 172,
"column": 73
} | [
{
"pp": "u : ℕ → ℝ\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 - ↑n * l ≤... | by
have L : Tendsto (fun ε => l + ε * (1 + ε + l)) (𝓝[>] 0) (𝓝 (l + 0 * (1 + 0 + l))) := by
apply Tendsto.mono_left _ nhdsWithin_le_nhds
exact
tendsto_const_nhds.add
(tendsto_id.mul ((tendsto_const_nhds.add tendsto_id).add tendsto_const_nhds))
simp only [zero_mul, add... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Analysis.SpecificLimits.FloorPow | {
"line": 174,
"column": 4
} | {
"line": 177,
"column": 17
} | [
{
"pp": "case h\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 - ... | calc
u n / n ≤ (n * l + ε * (1 + ε + l) * n) / n := by gcongr; linarith only [hn]
_ = (l + ε * (1 + ε + l)) := by field
_ < d := hε | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcTactic |
Mathlib.Analysis.SpecificLimits.FloorPow | {
"line": 277,
"column": 4
} | {
"line": 297,
"column": 11
} | [] | (∑ i ∈ range N with j < ⌊c ^ i⌋₊, (1 : ℝ) / (⌊c ^ i⌋₊ : ℝ) ^ 2) ≤
∑ i ∈ range N with j < c ^ i, (1 : ℝ) / (⌊c ^ i⌋₊ : ℝ) ^ 2 := by
gcongr with k hk; exact Nat.floor_le (by positivity)
_ ≤ ∑ i ∈ range N with j < c ^ i, (1 - c⁻¹)⁻¹ ^ 2 * ((1 : ℝ) / (c ^ i) ^ 2) := by
gcongr with i
rw [mul_di... | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcSteps |
Mathlib.CategoryTheory.Limits.IndYoneda | {
"line": 78,
"column": 2
} | {
"line": 81,
"column": 73
} | [
{
"pp": "C : Type u₁\ninst✝³ : Category.{u₂, u₁} C\nI : Type v₁\ninst✝² : Category.{v₂, v₁} I\nF : I ⥤ C\ninst✝¹ : HasColimit F\ninst✝ : HasLimitsOfShape Iᵒᵖ (Type u₂)\nA : C\ni : I\n⊢ (colimitHomIsoLimitYoneda F A).hom ≫ limit.π (F.op ⋙ yoneda.obj A) (op i) = (yoneda.obj A).map (colimit.ι F i).op",
"usedCo... | simp only [colimitHomIsoLimitYoneda, Iso.trans_hom, Iso.app_hom, Category.assoc]
erw [limitObjIsoLimitCompEvaluation_hom_π]
change ((coyonedaOpColimitIsoLimitCoyoneda F).hom ≫ _).app A = _
rw [coyonedaOpColimitIsoLimitCoyoneda_hom_comp_π, Functor.flip_map_app] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.IndYoneda | {
"line": 78,
"column": 2
} | {
"line": 81,
"column": 73
} | [
{
"pp": "C : Type u₁\ninst✝³ : Category.{u₂, u₁} C\nI : Type v₁\ninst✝² : Category.{v₂, v₁} I\nF : I ⥤ C\ninst✝¹ : HasColimit F\ninst✝ : HasLimitsOfShape Iᵒᵖ (Type u₂)\nA : C\ni : I\n⊢ (colimitHomIsoLimitYoneda F A).hom ≫ limit.π (F.op ⋙ yoneda.obj A) (op i) = (yoneda.obj A).map (colimit.ι F i).op",
"usedCo... | simp only [colimitHomIsoLimitYoneda, Iso.trans_hom, Iso.app_hom, Category.assoc]
erw [limitObjIsoLimitCompEvaluation_hom_π]
change ((coyonedaOpColimitIsoLimitCoyoneda F).hom ≫ _).app A = _
rw [coyonedaOpColimitIsoLimitCoyoneda_hom_comp_π, Functor.flip_map_app] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Connected | {
"line": 46,
"column": 2
} | {
"line": 47,
"column": 38
} | [
{
"pp": "J : Type w\ninst✝⁵ : Category.{w', w} J\ninst✝⁴ : IsConnected J\nC : Type u\ninst✝³ : Category.{v, u} C\ninst✝² : HasPullbacks C\ninst✝¹ : HasColimitsOfShape J C\ninst✝ : HasExactColimitsOfShape J C\nF : J ⥤ C\nc : Cocone F\nhc : IsColimit c\nX : C\nf : X ⟶ c.pt\n⊢ IsColimit { pt := X, ι := pullback.sn... | suffices IsIso (colimMap (pullback.snd c.ι ((Functor.const J).map f))) from
Cocone.isColimitOfIsIsoColimMapι _ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSuffices__1 | Lean.Parser.Tactic.tacticSuffices_ |
Mathlib.CategoryTheory.MorphismProperty.OfObjectProperty | {
"line": 58,
"column": 4
} | {
"line": 58,
"column": 31
} | [
{
"pp": "C : Type u_1\ninst✝¹ : Category.{v_1, u_1} C\nP Q : ObjectProperty C\ninst✝ : P.IsClosedUnderIsomorphisms\n⊢ ∀ {X Y Z : C} (i : X ⟶ Y), isomorphisms C i → ∀ (f : Y ⟶ Z), ofObjectProperty P Q f → ofObjectProperty P Q (i ≫ f)",
"usedConstants": []
}
] | intro X Y Z i hi f ⟨hY, hZ⟩ | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.CategoryTheory.MorphismProperty.OfObjectProperty | {
"line": 64,
"column": 4
} | {
"line": 64,
"column": 31
} | [
{
"pp": "C : Type u_1\ninst✝¹ : Category.{v_1, u_1} C\nP Q : ObjectProperty C\ninst✝ : Q.IsClosedUnderIsomorphisms\n⊢ ∀ {X Y Z : C} (i : Y ⟶ Z), isomorphisms C i → ∀ (f : X ⟶ Y), ofObjectProperty P Q f → ofObjectProperty P Q (f ≫ i)",
"usedConstants": []
}
] | intro X Y Z i hi f ⟨hY, hZ⟩ | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.CategoryTheory.Abelian.SerreClass.Localization | {
"line": 268,
"column": 2
} | {
"line": 285,
"column": 55
} | [
{
"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 : D\nf : X ⟶ Y\n⊢ Epi f ↔ ∃ X' Y' f', ∃ (_ : Epi f'),... | have := preservesEpimorphisms L P
have := Localization.essSurj_mapArrow L P.isoModSerre
refine ⟨fun _ ↦ ?_, ?_⟩
· suffices ∀ ⦃X Y : C⦄ (f : X ⟶ Y) (_ : Epi (L.map f)),
∃ (X' Y' : C) (f' : X' ⟶ Y') (_ : Epi f'),
Nonempty (Arrow.mk (L.map f') ≅ Arrow.mk (L.map f)) by
let e := L.mapArrow.objO... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Abelian.SerreClass.Localization | {
"line": 268,
"column": 2
} | {
"line": 285,
"column": 55
} | [
{
"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 : D\nf : X ⟶ Y\n⊢ Epi f ↔ ∃ X' Y' f', ∃ (_ : Epi f'),... | have := preservesEpimorphisms L P
have := Localization.essSurj_mapArrow L P.isoModSerre
refine ⟨fun _ ↦ ?_, ?_⟩
· suffices ∀ ⦃X Y : C⦄ (f : X ⟶ Y) (_ : Epi (L.map f)),
∃ (X' Y' : C) (f' : X' ⟶ Y') (_ : Epi f'),
Nonempty (Arrow.mk (L.map f') ≅ Arrow.mk (L.map f)) by
let e := L.mapArrow.objO... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Adjunction.Evaluation | {
"line": 78,
"column": 4
} | {
"line": 78,
"column": 35
} | [
{
"pp": "case mpr\nC : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\ninst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D\nF G : C ⥤ D\nη : F ⟶ G\na✝ : ∀ (c : C), Mono (η.app c)\n⊢ Mono η",
"usedConstants": [
"CategoryTheory.NatTrans.mono_of_mono_app"
]
}
] | apply NatTrans.mono_of_mono_app | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.CategoryTheory.Adjunction.Lifting.Left | {
"line": 156,
"column": 6
} | {
"line": 158,
"column": 68
} | [
{
"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... | rw [← (adj₁.homEquiv _ _).symm.injective.eq_iff, adj₁.homEquiv_counit,
adj₁.homEquiv_counit, adj₁.homEquiv_counit, F.map_comp, assoc, U.map_comp, F.map_comp,
assoc, adj₁.counit_naturality, adj₁.counit_naturality_assoc] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Adjunction.Triple | {
"line": 191,
"column": 6
} | {
"line": 191,
"column": 51
} | [
{
"pp": "C : Type u_1\nD : Type u_2\ninst✝⁴ : Category.{v_1, u_1} C\ninst✝³ : Category.{v_2, u_2} D\nF : C ⥤ D\nG : D ⥤ C\nH : C ⥤ D\nt : Triple F G H\ninst✝² : G.Full\ninst✝¹ : G.Faithful\ninst✝ : H.PreservesEpimorphisms\nX : C\nx✝ : G.IsLeftAdjoint\nh : Epi (t.adj₂.counit.app X ≫ t.adj₁.unit.app X)\n⊢ Epi (t.... | epi_rightToLeft_app_iff_epi_map_adj₁_unit_app | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Adjunction.Lifting.Right | {
"line": 165,
"column": 7
} | {
"line": 165,
"column": 35
} | [
{
"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 : A ⥤ B\nF : B ⥤ A\nL : C ⥤ B\nU' : A ⥤ C\nadj₁ : F ⊣ U\nadj₂ : L ⋙ F ⊣ U'\ninst✝ : HasCoreflexiveEqualizers C\nh✝ : (X : B) → RegularMono (adj₁.unit.app X)\nX Y : C\nY' : ... | Fork.IsLimit.homIso_natural, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | {
"line": 196,
"column": 77
} | {
"line": 197,
"column": 37
} | [
{
"pp": "B : Type u₁\ninst✝¹ : Bicategory B\nC : Type u₂\ninst✝ : Bicategory C\nF G : B ⥤ᵖ C\nα : F ⟶ G\na : B\n⊢ (α.naturality (𝟙 a)).hom =\n (F.mapId a).hom ▷ α.app a ≫ (λ_ (α.app a)).hom ≫ (ρ_ (α.app a)).inv ≫ α.app a ◁ (G.mapId a).inv",
"usedConstants": [
"CategoryTheory.Pseudofunctor.StrongTr... | by
simp [← assoc, ← IsIso.comp_inv_eq] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | {
"line": 234,
"column": 39
} | {
"line": 235,
"column": 37
} | [
{
"pp": "B : Type u₁\ninst✝¹ : Bicategory B\nC : Type u₂\ninst✝ : Bicategory C\nF G : B ⥤ᵖ C\nα : F ⟶ G\na b c : B\nf : a ⟶ b\ng : b ⟶ c\n⊢ (α.naturality (f ≫ g)).hom =\n (F.mapComp f g).hom ▷ α.app c ≫\n (α_ (F.map f) (F.map g) (α.app c)).hom ≫\n F.map f ◁ (α.naturality g).hom ≫\n (α_ (... | by
simp [← assoc, ← IsIso.comp_inv_eq] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.PFun | {
"line": 199,
"column": 25
} | {
"line": 199,
"column": 80
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nδ : Type u_4\nε : Type u_5\nι : Type u_6\nα✝ : Type u_7\nf : α →. α✝\n⊢ id <$> f = f",
"usedConstants": [
"Part",
"Part.mk",
"PFun",
"Part.casesOn",
"Monad.toApplicative",
"PFun.monad",
"id",
"funext",
"... | funext a; dsimp [Functor.map, PFun.map]; cases f a; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PFun | {
"line": 199,
"column": 25
} | {
"line": 199,
"column": 80
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nδ : Type u_4\nε : Type u_5\nι : Type u_6\nα✝ : Type u_7\nf : α →. α✝\n⊢ id <$> f = f",
"usedConstants": [
"Part",
"Part.mk",
"PFun",
"Part.casesOn",
"Monad.toApplicative",
"PFun.monad",
"id",
"funext",
"... | funext a; dsimp [Functor.map, PFun.map]; cases f a; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Category.Cat.Limit | {
"line": 55,
"column": 4
} | {
"line": 55,
"column": 53
} | [
{
"pp": "case refine_2\nJ : Type v\ninst✝ : SmallCategory J\nF : J ⥤ Cat\nX Y : limit (F ⋙ objects)\nX✝ Y✝ : J\nf : X✝ ⟶ Y✝\ng : (hom (limit.π (F ⋙ objects) X✝)) X ⟶ (hom (limit.π (F ⋙ objects) X✝)) Y\n⊢ (F.map f).toFunctor.obj ((hom (limit.π (F ⋙ objects) X✝)) Y) = (hom (limit.π (F ⋙ objects) Y✝)) Y",
"use... | · exact congr_hom (limit.w (F ⋙ Cat.objects) f) Y | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.PFun | {
"line": 559,
"column": 2
} | {
"line": 561,
"column": 75
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nδ : Type u_4\nf : α →. γ\ng : β →. δ\nx : α × β\ny : γ × δ\n⊢ y ∈ f.prodMap g x ↔ y.1 ∈ f x.1 ∧ y.2 ∈ g x.2",
"usedConstants": [
"Iff.mpr",
"Part",
"Part.mk",
"_private.Mathlib.Data.PFun.0.PFun.mem_prodMap._simp_1_2",
"PFun.pro... | trans ∃ hp hq, (f x.1).get hp = y.1 ∧ (g x.2).get hq = y.2
· simp only [prodMap, Part.mem_mk_iff, And.exists, Prod.ext_iff]
· simp only [exists_and_left, exists_and_right, Membership.mem, Part.Mem] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PFun | {
"line": 559,
"column": 2
} | {
"line": 561,
"column": 75
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nδ : Type u_4\nf : α →. γ\ng : β →. δ\nx : α × β\ny : γ × δ\n⊢ y ∈ f.prodMap g x ↔ y.1 ∈ f x.1 ∧ y.2 ∈ g x.2",
"usedConstants": [
"Iff.mpr",
"Part",
"Part.mk",
"_private.Mathlib.Data.PFun.0.PFun.mem_prodMap._simp_1_2",
"PFun.pro... | trans ∃ hp hq, (f x.1).get hp = y.1 ∧ (g x.2).get hq = y.2
· simp only [prodMap, Part.mem_mk_iff, And.exists, Prod.ext_iff]
· simp only [exists_and_left, exists_and_right, Membership.mem, Part.Mem] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.End | {
"line": 247,
"column": 4
} | {
"line": 247,
"column": 44
} | [
{
"pp": "J : Type u\ninst✝³ : Category.{v, u} J\nC : Type u'\ninst✝² : Category.{v', u'} C\nF : Jᵒᵖ ⥤ J ⥤ C\ninst✝¹ : HasEnd F\nX : C\nf✝ : (j : J) → X ⟶ (F.obj (op j)).obj j\nhf : ∀ ⦃i j : J⦄ (g : i ⟶ j), f✝ i ≫ (F.obj (op i)).map g = f✝ j ≫ (F.map g.op).app j\nF' : Jᵒᵖ ⥤ J ⥤ C\ninst✝ : HasEnd F'\nf : F ⟶ F'\n... | rw [← e, reassoc_of% end_.condition F φ] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Endofunctor.Algebra | {
"line": 205,
"column": 68
} | {
"line": 205,
"column": 75
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nF : C ⥤ C\nA✝ A₀ A₁ A₂ : Algebra F\nf : A₀ ⟶ A₁\ng : A₁ ⟶ A₂\nA : Algebra F\nh : Limits.IsInitial A\n⊢ (F.map (h.to { a := F.obj A.a, str := F.map A.str }).f ≫ F.map A.str) ≫ A.str =\n (A.str ≫ (h.to { a := F.obj A.a, str := F.map A.str }).f) ≫ A.str",
"use... | ← Hom.h | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Endofunctor.Algebra | {
"line": 397,
"column": 66
} | {
"line": 397,
"column": 73
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nF : C ⥤ C\nV V₀ V₁ V₂ : Coalgebra F\nf : V₀ ⟶ V₁\ng : V₁ ⟶ V₂\nA : Coalgebra F\nh : Limits.IsTerminal A\n⊢ A.str ≫ F.map A.str ≫ F.map (h.from { V := F.obj A.V, str := F.map A.str }).f =\n A.str ≫ (h.from { V := F.obj A.V, str := F.map A.str }).f ≫ A.str",
... | ← Hom.h | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Functor.Derived.RightDerived | {
"line": 144,
"column": 73
} | {
"line": 147,
"column": 52
} | [
{
"pp": "C : Type u_3\nD : Type u_1\nH : Type u_2\ninst✝⁴ : Category.{v_1, u_3} C\ninst✝³ : Category.{v_3, u_1} D\ninst✝² : Category.{v_5, u_2} H\nRF : D ⥤ H\nF : C ⥤ H\nL : C ⥤ D\nα : F ⟶ L ⋙ RF\nW : MorphismProperty C\ninst✝¹ : L.IsLocalization W\ninst✝ : RF.IsRightDerivedFunctor α W\nG : D ⥤ H\nβ : F ⟶ L ⋙ G... | by
rw [isRightDerivedFunctor_iff_isLeftKanExtension]
have := IsRightDerivedFunctor.isLeftKanExtension _ α W
exact isLeftKanExtension_iff_isIso _ α _ (by simp) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Functor.Derived.PointwiseLeftDerived | {
"line": 72,
"column": 2
} | {
"line": 72,
"column": 58
} | [
{
"pp": "C : Type u₁\nH : Type u₃\ninst✝¹ : Category.{v₁, u₁} C\ninst✝ : Category.{v₃, u₃} H\nF : C ⥤ H\nW : MorphismProperty C\nX Y : C\nw : X ⟶ Y\nhw : W w\n⊢ F.HasPointwiseLeftDerivedFunctorAt W X ↔ F.HasPointwiseLeftDerivedFunctorAt W Y",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Functor.... | simp only [F.hasPointwiseLeftDerivedFunctorAt_iff W.Q W] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.FintypeCat | {
"line": 34,
"column": 48
} | {
"line": 36,
"column": 16
} | [
{
"pp": "J : Type\ninst✝ : SmallCategory J\nK : J ⥤ FintypeCat\nj : J\n⊢ Finite ((K ⋙ FintypeCat.incl).obj j)",
"usedConstants": [
"Finite",
"FintypeCat",
"CategoryTheory.Functor.comp",
"inferInstance",
"id",
"CategoryTheory.ObjectProperty.FullSubcategory.obj",
"Fin... | by
simp only [comp_obj, FintypeCat.incl_obj]
infer_instance | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Galois.Decomposition | {
"line": 289,
"column": 4
} | {
"line": 289,
"column": 21
} | [
{
"pp": "case h\nC : Type u₁\ninst✝² : Category.{u₂, u₁} C\ninst✝¹ : GaloisCategory C\nF : C ⥤ FintypeCat\ninst✝ : FiberFunctor F\nX A : C\nu : A ⟶ selfProd F X\na : (F.obj A).obj\nh1 : (ConcreteCategory.hom (F.map u)) a = mkSelfProdFib F X\nh2 : IsConnected A\nh3 : Mono u\nx y : (F.obj A).obj\nfi1 : A ≅ A\nhfi... | rw [hfi1, ← hfi2] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Galois.Prorepresentability | {
"line": 357,
"column": 2
} | {
"line": 357,
"column": 86
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{u₂, u₁} C\ninst✝¹ : GaloisCategory C\nF : C ⥤ FintypeCat\ninst✝ : FiberFunctor F\nf g : End F\n⊢ (endEquivAutGalois F) (g ≫ f) = (endEquivAutGalois F) g * (endEquivAutGalois F) f",
"usedConstants": [
"CategoryTheory.GaloisCategory.toPreGaloisCategory",
"C... | refine AutGalois.ext F (fun A ↦ evaluation_aut_injective_of_isConnected F A A.pt ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.CategoryTheory.Groupoid.Basic | {
"line": 30,
"column": 28
} | {
"line": 31,
"column": 97
} | [
{
"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 g ≫ g = f ≫ inv f ≫ g",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Groupoid.inv",
... | congr 1
simp only [inv_eq_inv, IsIso.inv_hom_id, eq_iff_true_of_subsingleton] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Groupoid.Basic | {
"line": 30,
"column": 28
} | {
"line": 31,
"column": 97
} | [
{
"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 g ≫ g = f ≫ inv f ≫ g",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Groupoid.inv",
... | congr 1
simp only [inv_eq_inv, IsIso.inv_hom_id, eq_iff_true_of_subsingleton] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | {
"line": 108,
"column": 6
} | {
"line": 108,
"column": 17
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nG : Type u₁\ninst✝ : Groupoid G\nφ : C ⥤ G\nx✝¹ x✝ : Quiver.FreeGroupoid C\nf g : x✝¹ ⟶ x✝\nr : homRel C f g\nthis :\n ∀ {X Y : C} (f : X ⟶ Y),\n Quiver.homOfEq ((Quiver.FreeGroupoid.of C ⋙q (Quiver.FreeGroupoid.lift φ.toPrefunctor).toPrefunctor).map f) ⋯ ⋯ =... | induction r | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | {
"line": 150,
"column": 19
} | {
"line": 150,
"column": 82
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nG✝ : Type u₁\ninst✝ : Groupoid G✝\nF G : FreeGroupoid C ⥤ G✝\nh : of C ⋙ F = of C ⋙ G\n⊢ F = G",
"usedConstants": [
"CategoryTheory.FreeGroupoid",
"Eq.mpr",
"CategoryTheory.Functor",
"congrArg",
"CategoryTheory.Functor.comp",
... | rw [lift_unique (of C ⋙ G) F h, ← lift_unique (of C ⋙ G) G rfl] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | {
"line": 150,
"column": 19
} | {
"line": 150,
"column": 82
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nG✝ : Type u₁\ninst✝ : Groupoid G✝\nF G : FreeGroupoid C ⥤ G✝\nh : of C ⋙ F = of C ⋙ G\n⊢ F = G",
"usedConstants": [
"CategoryTheory.FreeGroupoid",
"Eq.mpr",
"CategoryTheory.Functor",
"congrArg",
"CategoryTheory.Functor.comp",
... | rw [lift_unique (of C ⋙ G) F h, ← lift_unique (of C ⋙ G) G rfl] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | {
"line": 150,
"column": 19
} | {
"line": 150,
"column": 82
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nG✝ : Type u₁\ninst✝ : Groupoid G✝\nF G : FreeGroupoid C ⥤ G✝\nh : of C ⋙ F = of C ⋙ G\n⊢ F = G",
"usedConstants": [
"CategoryTheory.FreeGroupoid",
"Eq.mpr",
"CategoryTheory.Functor",
"congrArg",
"CategoryTheory.Functor.comp",
... | rw [lift_unique (of C ⋙ G) F h, ← lift_unique (of C ⋙ G) G rfl] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Groupoid.Subgroupoid | {
"line": 182,
"column": 22
} | {
"line": 182,
"column": 34
} | [
{
"pp": "C : Type u\ninst✝ : Groupoid C\nS T : Subgroupoid C\n⊢ (∀ ⦃x : (c : C) × (d : C) × (c ⟶ d)⦄, x ∈ S → x ∈ T) ↔ ∀ {c d : C}, S.arrows c d ⊆ T.arrows c d",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Membership.mem",
... | Sigma.forall | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.LiftingProperties.PushoutProduct | {
"line": 119,
"column": 56
} | {
"line": 123,
"column": 22
} | [
{
"pp": "C : Type u\ninst✝⁵ : Category.{v, u} C\ninst✝⁴ : HasPushouts C\ninst✝³ : HasPullbacks C\ninst✝² : CartesianMonoidalCategory C\ninst✝¹ : MonoidalClosed C\ninst✝ : BraidedCategory C\nA B K L X Y : C\nf : A ⟶ B\ni : IsInitial K\nt : IsTerminal Y\n⊢ HasLiftingProperty (Arrow.mk f □ Arrow.mk (i.to L)).hom (... | by
rw [hasLiftingProperty_mk_isInitial_iff']
exact HasLiftingProperty.iff_of_arrow_iso_right f
(Arrow.isoMk' _ _ (Iso.refl _) ((IsTerminal.isTerminalObj (ihom L) _ t).uniqueUpToIso t)
(t.hom_ext _ _)) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Join.Pseudofunctor | {
"line": 61,
"column": 33
} | {
"line": 61,
"column": 51
} | [
{
"pp": "case h₁.w.h\nA : Type u_1\nB : Type u_2\nC : Type u_3\nD : Type u_4\ninst✝³ : Category.{v_1, u_1} A\ninst✝² : Category.{v_2, u_2} B\ninst✝¹ : Category.{v_3, u_3} C\ninst✝ : Category.{v_4, u_4} D\nF : A ⥤ B\nG H : B ⥤ C\nη : G ⟶ H\nx✝ : A\n⊢ ((inclLeft A D).whiskerLeft (mapWhiskerRight (F.whiskerLeft η)... | simp [mapCompLeft] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Join.Pseudofunctor | {
"line": 61,
"column": 33
} | {
"line": 61,
"column": 51
} | [
{
"pp": "case h₂.w.h\nA : Type u_1\nB : Type u_2\nC : Type u_3\nD : Type u_4\ninst✝³ : Category.{v_1, u_1} A\ninst✝² : Category.{v_2, u_2} B\ninst✝¹ : Category.{v_3, u_3} C\ninst✝ : Category.{v_4, u_4} D\nF : A ⥤ B\nG H : B ⥤ C\nη : G ⟶ H\nx✝ : D\n⊢ ((inclRight A D).whiskerLeft (mapWhiskerRight (F.whiskerLeft η... | simp [mapCompLeft] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Join.Pseudofunctor | {
"line": 79,
"column": 33
} | {
"line": 79,
"column": 51
} | [
{
"pp": "case h₁.w.h\nA : Type u_1\nB : Type u_2\nC : Type u_3\nD : Type u_4\ninst✝³ : Category.{v_1, u_1} A\ninst✝² : Category.{v_2, u_2} B\ninst✝¹ : Category.{v_3, u_3} C\ninst✝ : Category.{v_4, u_4} D\nF G : A ⥤ B\nη : F ⟶ G\nH : B ⥤ C\nx✝ : A\n⊢ ((inclLeft A D).whiskerLeft (mapWhiskerRight (Functor.whiskerR... | simp [mapCompLeft] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Join.Pseudofunctor | {
"line": 79,
"column": 33
} | {
"line": 79,
"column": 51
} | [
{
"pp": "case h₂.w.h\nA : Type u_1\nB : Type u_2\nC : Type u_3\nD : Type u_4\ninst✝³ : Category.{v_1, u_1} A\ninst✝² : Category.{v_2, u_2} B\ninst✝¹ : Category.{v_3, u_3} C\ninst✝ : Category.{v_4, u_4} D\nF G : A ⥤ B\nη : F ⟶ G\nH : B ⥤ C\nx✝ : D\n⊢ ((inclRight A D).whiskerLeft (mapWhiskerRight (Functor.whisker... | simp [mapCompLeft] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Join.Pseudofunctor | {
"line": 98,
"column": 33
} | {
"line": 98,
"column": 51
} | [
{
"pp": "case h₁.w.h\nA : Type u_1\nB : Type u_2\nC : Type u_3\nD : Type u_4\ninst✝⁴ : Category.{v_1, u_1} A\ninst✝³ : Category.{v_2, u_2} B\ninst✝² : Category.{v_3, u_3} C\ninst✝¹ : Category.{v_4, u_4} D\nE : Type u_5\ninst✝ : Category.{v_5, u_5} E\nF : A ⥤ B\nG : B ⥤ C\nH : C ⥤ D\nx✝ : A\n⊢ ((inclLeft A E).wh... | simp [mapCompLeft] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Join.Pseudofunctor | {
"line": 98,
"column": 33
} | {
"line": 98,
"column": 51
} | [
{
"pp": "case h₂.w.h\nA : Type u_1\nB : Type u_2\nC : Type u_3\nD : Type u_4\ninst✝⁴ : Category.{v_1, u_1} A\ninst✝³ : Category.{v_2, u_2} B\ninst✝² : Category.{v_3, u_3} C\ninst✝¹ : Category.{v_4, u_4} D\nE : Type u_5\ninst✝ : Category.{v_5, u_5} E\nF : A ⥤ B\nG : B ⥤ C\nH : C ⥤ D\nx✝ : E\n⊢ ((inclRight A E).w... | simp [mapCompLeft] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Join.Pseudofunctor | {
"line": 112,
"column": 33
} | {
"line": 112,
"column": 51
} | [
{
"pp": "case h₁.w.h\nA : Type u_1\nB : Type u_2\nC : Type u_3\ninst✝² : Category.{v_1, u_1} A\ninst✝¹ : Category.{v_2, u_2} B\ninst✝ : Category.{v_3, u_3} C\nF : A ⥤ B\nx✝ : A\n⊢ ((inclLeft A C).whiskerLeft (mapWhiskerRight F.leftUnitor.hom (𝟭 C))).app x✝ =\n ((inclLeft A C).whiskerLeft\n ((mapCom... | simp [mapCompLeft] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Join.Pseudofunctor | {
"line": 112,
"column": 33
} | {
"line": 112,
"column": 51
} | [
{
"pp": "case h₂.w.h\nA : Type u_1\nB : Type u_2\nC : Type u_3\ninst✝² : Category.{v_1, u_1} A\ninst✝¹ : Category.{v_2, u_2} B\ninst✝ : Category.{v_3, u_3} C\nF : A ⥤ B\nx✝ : C\n⊢ ((inclRight A C).whiskerLeft (mapWhiskerRight F.leftUnitor.hom (𝟭 C))).app x✝ =\n ((inclRight A C).whiskerLeft\n ((mapC... | simp [mapCompLeft] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Join.Pseudofunctor | {
"line": 126,
"column": 33
} | {
"line": 126,
"column": 51
} | [
{
"pp": "case h₁.w.h\nA : Type u_1\nB : Type u_2\nC : Type u_3\ninst✝² : Category.{v_1, u_1} A\ninst✝¹ : Category.{v_2, u_2} B\ninst✝ : Category.{v_3, u_3} C\nF : A ⥤ B\nx✝ : A\n⊢ ((inclLeft A C).whiskerLeft (mapWhiskerRight F.rightUnitor.hom (𝟭 C))).app x✝ =\n ((inclLeft A C).whiskerLeft\n ((mapCo... | simp [mapCompLeft] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Join.Pseudofunctor | {
"line": 126,
"column": 33
} | {
"line": 126,
"column": 51
} | [
{
"pp": "case h₂.w.h\nA : Type u_1\nB : Type u_2\nC : Type u_3\ninst✝² : Category.{v_1, u_1} A\ninst✝¹ : Category.{v_2, u_2} B\ninst✝ : Category.{v_3, u_3} C\nF : A ⥤ B\nx✝ : C\n⊢ ((inclRight A C).whiskerLeft (mapWhiskerRight F.rightUnitor.hom (𝟭 C))).app x✝ =\n ((inclRight A C).whiskerLeft\n ((map... | simp [mapCompLeft] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Join.Pseudofunctor | {
"line": 140,
"column": 24
} | {
"line": 140,
"column": 94
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\n⊢ ∀ {a b c : Cat} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c),\n NatTrans.toCatHom₂ (mapWhiskerLeft (𝟭 C) (η ▷ h).toNatTrans) =\n (Cat.Hom.isoMk (mapCompRight C f.toFunctor h.toFunctor)).hom ≫\n NatTrans.toCatHom₂ (mapWhiskerLeft (𝟭 C) η.toNatTrans) ... | by intros; exact congr($(mapWhiskerLeft_whiskerRight C _ _).toCatHom₂) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Localization.Pi | {
"line": 39,
"column": 4
} | {
"line": 39,
"column": 33
} | [
{
"pp": "case of_equiv\nJ₁ J₂ : Type w\ne : J₁ ≃ J₂\nhJ₁ :\n ∀ {C : J₁ → Type u₁} {D : J₁ → Type u₂} [inst : (j : J₁) → Category.{v₁, u₁} (C j)]\n [inst_1 : (j : J₁) → Category.{v₂, u₂} (D j)] (L : (j : J₁) → C j ⥤ D j) (W : (j : J₁) → MorphismProperty (C j))\n [∀ (j : J₁), (W j).ContainsIdentities] [∀ (... | let L₁ := fun j => (L₂ (e j)) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.CategoryTheory.Localization.Pi | {
"line": 58,
"column": 43
} | {
"line": 58,
"column": 55
} | [
{
"pp": "case h_empty\nC : PEmpty.{w + 1} → Type u₁\nD : PEmpty.{w + 1} → Type u₂\ninst✝³ : (j : PEmpty.{w + 1}) → Category.{v₁, u₁} (C j)\ninst✝² : (j : PEmpty.{w + 1}) → Category.{v₂, u₂} (D j)\nL : (j : PEmpty.{w + 1}) → C j ⥤ D j\nW : (j : PEmpty.{w + 1}) → MorphismProperty (C j)\ninst✝¹ : ∀ (j : PEmpty.{w ... | isIso_pi_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Localization.Monoidal.Braided | {
"line": 115,
"column": 8
} | {
"line": 115,
"column": 50
} | [
{
"pp": "case a.a.a.a.a.a.a.a.a\nC : Type u_1\nD : Type u_2\ninst✝⁵ : Category.{v_1, u_1} C\ninst✝⁴ : Category.{v_2, u_2} D\nL : C ⥤ D\nW : MorphismProperty C\ninst✝³ : MonoidalCategory C\ninst✝² : W.IsMonoidal\ninst✝¹ : L.IsLocalization W\nunit : D\nε : L.obj (𝟙_ C) ≅ unit\ninst✝ : BraidedCategory C\nX Y Z : ... | braidingNatIso_hom_app_naturality_μ_right, | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.CategoryTheory.Monoidal.Free.Basic | {
"line": 329,
"column": 6
} | {
"line": 329,
"column": 80
} | [
{
"pp": "case tensorHom_comp_tensorHom\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... | dsimp only [projectMapAux]; rw [MonoidalCategory.tensorHom_comp_tensorHom] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Monoidal.Free.Basic | {
"line": 329,
"column": 6
} | {
"line": 329,
"column": 80
} | [
{
"pp": "case tensorHom_comp_tensorHom\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... | dsimp only [projectMapAux]; rw [MonoidalCategory.tensorHom_comp_tensorHom] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.Braided.Reflection | {
"line": 171,
"column": 4
} | {
"line": 171,
"column": 36
} | [
{
"pp": "case out.h.toFun.h\nC : Type u_1\nD : Type u_2\ninst✝⁶ : Category.{v_1, u_1} C\ninst✝⁵ : Category.{v_2, u_2} D\ninst✝⁴ : MonoidalCategory D\ninst✝³ : SymmetricCategory D\ninst✝² : MonoidalClosed D\nR : C ⥤ D\ninst✝¹ : R.Faithful\ninst✝ : R.Full\nL : D ⥤ C\nadj : L ⊣ R\ntfae_3_to_4 :\n (∀ (d d' : D), I... | simp [← map_comp, -map_preimage] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Monoidal.Bimod | {
"line": 326,
"column": 19
} | {
"line": 327,
"column": 22
} | [
{
"pp": "case a\nC : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\ninst✝³ : MonoidalCategory C\ninst✝² : HasCoequalizers C\nR S T : Mon C\nP : Bimod R S\nQ : Bimod S T\ninst✝¹ : ∀ (X : C), PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)\ninst✝ : ∀ (X : C), PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (... | rw [← comp_whiskerRight, whiskerLeft_π_actLeft, comp_whiskerRight,
comp_whiskerRight] | Lean.Parser.Tactic.Conv._aux_Init_Conv___macroRules_Lean_Parser_Tactic_Conv_convRw___1 | Lean.Parser.Tactic.Conv.convRw__ |
Mathlib.CategoryTheory.Monoidal.Bimod | {
"line": 326,
"column": 19
} | {
"line": 327,
"column": 22
} | [
{
"pp": "case a\nC : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\ninst✝³ : MonoidalCategory C\ninst✝² : HasCoequalizers C\nR S T : Mon C\nP : Bimod R S\nQ : Bimod S T\ninst✝¹ : ∀ (X : C), PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)\ninst✝ : ∀ (X : C), PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (... | rw [← comp_whiskerRight, whiskerLeft_π_actLeft, comp_whiskerRight,
comp_whiskerRight] | Lean.Elab.Tactic.Conv.evalConvSeq1Indented | Lean.Parser.Tactic.Conv.convSeq1Indented |
Mathlib.CategoryTheory.Monoidal.Bimod | {
"line": 326,
"column": 19
} | {
"line": 327,
"column": 22
} | [
{
"pp": "case a\nC : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\ninst✝³ : MonoidalCategory C\ninst✝² : HasCoequalizers C\nR S T : Mon C\nP : Bimod R S\nQ : Bimod S T\ninst✝¹ : ∀ (X : C), PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)\ninst✝ : ∀ (X : C), PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (... | rw [← comp_whiskerRight, whiskerLeft_π_actLeft, comp_whiskerRight,
comp_whiskerRight] | Lean.Elab.Tactic.Conv.evalConvSeq | Lean.Parser.Tactic.Conv.convSeq |
Mathlib.CategoryTheory.Subterminal | {
"line": 70,
"column": 2
} | {
"line": 71,
"column": 18
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nA T : C\nhT : IsTerminal T\ninst✝ : Mono (hT.from A)\nZ : C\nf g : Z ⟶ A\n⊢ f = g",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Limits.IsTerminal.from",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
... | rw [← cancel_mono (hT.from A)]
apply hT.hom_ext | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Subterminal | {
"line": 70,
"column": 2
} | {
"line": 71,
"column": 18
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nA T : C\nhT : IsTerminal T\ninst✝ : Mono (hT.from A)\nZ : C\nf g : Z ⟶ A\n⊢ f = g",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Limits.IsTerminal.from",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
... | rw [← cancel_mono (hT.from A)]
apply hT.hom_ext | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor | {
"line": 199,
"column": 2
} | {
"line": 199,
"column": 40
} | [
{
"pp": "C : Type u₁\ninst✝⁹ : Category.{v₁, u₁} C\nV : Type u₂\ninst✝⁸ : Category.{v₂, u₂} V\ninst✝⁷ : MonoidalCategory C\ninst✝⁶ : MonoidalCategory V\nhasDayConvolution : ∀ (F G : C ⥤ V), (tensor C).HasPointwiseLeftKanExtension (F ⊠ G)\nhasDayConvolutionUnit : (Functor.fromPUnit (𝟙_ C)).HasPointwiseLeftKanEx... | simp [η, isoPointwiseLeftKanExtension] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor | {
"line": 199,
"column": 2
} | {
"line": 199,
"column": 40
} | [
{
"pp": "C : Type u₁\ninst✝⁹ : Category.{v₁, u₁} C\nV : Type u₂\ninst✝⁸ : Category.{v₂, u₂} V\ninst✝⁷ : MonoidalCategory C\ninst✝⁶ : MonoidalCategory V\nhasDayConvolution : ∀ (F G : C ⥤ V), (tensor C).HasPointwiseLeftKanExtension (F ⊠ G)\nhasDayConvolutionUnit : (Functor.fromPUnit (𝟙_ C)).HasPointwiseLeftKanEx... | simp [η, isoPointwiseLeftKanExtension] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.