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.NumberTheory.ZetaValues | {
"line": 177,
"column": 8
} | {
"line": 184,
"column": 71
} | [
{
"pp": "m : ℕ\nm0 : m ≠ 0\nx : ℝ\nm0' : ↑m ≠ 0\nf : ℕ → ℝ → ℝ := fun k x ↦ bernoulliFun k (↑m * x) - ↑m ^ k / ↑m * ∑ i ∈ Finset.range m, bernoulliFun k (x + ↑i / ↑m)\nk : ℕ\nh : ∀ (x : ℝ), f k x = 0\nd : ∀ (x : ℝ), HasDerivAt (f (k + 1)) 0 x\nc : ℝ\nfc : ∀ (x : ℝ), f (k + 1) x = c\n⊢ ↑m ^ (k + 1) / ↑m = 0 ∨ ∫ ... | right
rw [intervalIntegral.integral_finsetSum]
· simp only [intervalIntegral.integral_comp_add_right, zero_add, ← one_div, ← add_div,
add_comm (1 : ℝ), ← Nat.cast_add_one]
rw [intervalIntegral.sum_integral_adjacent_intervals]
· simp [div_self m0', integral_bernoulliFun_eq... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.LSeries.HurwitzZetaValues | {
"line": 223,
"column": 6
} | {
"line": 223,
"column": 50
} | [
{
"pp": "case h.e'_2\n⊢ riemannZeta ↑4 = ↑(∑' (b : ℕ), ↑1 / ↑b ^ 4)",
"usedConstants": [
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"Real",
"Preorder.toLT",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Nat.instIsOrderedAddMonoid",
"riema... | zeta_nat_eq_tsum_of_gt_one (by simp : 1 < 4) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.ZetaValues | {
"line": 314,
"column": 8
} | {
"line": 314,
"column": 65
} | [
{
"pp": "case h.e'_6\nk : ℕ\nhk : 2 ≤ k\nhx : 1 ∈ Icc 0 1\nthis :\n ∀ {y : ℝ}, y ∈ Ico 0 1 → HasSum (fun n ↦ 1 / ↑n ^ k * (fourier n) ↑y) (-(2 * ↑π * I) ^ k / ↑k ! * ↑(bernoulliFun k y))\n⊢ -(2 * ↑π * I) ^ k / ↑k ! * ↑(bernoulliFun k 1) = -(2 * ↑π * I) ^ k / ↑k ! * ↑(bernoulliFun k 0)",
"usedConstants": [
... | rw [bernoulliFun_endpoints_eq_of_ne_one (by lia : k ≠ 1)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.NumberTheory.ZetaValues | {
"line": 314,
"column": 8
} | {
"line": 314,
"column": 65
} | [
{
"pp": "case h.e'_6\nk : ℕ\nhk : 2 ≤ k\nhx : 1 ∈ Icc 0 1\nthis :\n ∀ {y : ℝ}, y ∈ Ico 0 1 → HasSum (fun n ↦ 1 / ↑n ^ k * (fourier n) ↑y) (-(2 * ↑π * I) ^ k / ↑k ! * ↑(bernoulliFun k y))\n⊢ -(2 * ↑π * I) ^ k / ↑k ! * ↑(bernoulliFun k 1) = -(2 * ↑π * I) ^ k / ↑k ! * ↑(bernoulliFun k 0)",
"usedConstants": [
... | rw [bernoulliFun_endpoints_eq_of_ne_one (by lia : k ≠ 1)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.ZetaValues | {
"line": 314,
"column": 8
} | {
"line": 314,
"column": 65
} | [
{
"pp": "case h.e'_6\nk : ℕ\nhk : 2 ≤ k\nhx : 1 ∈ Icc 0 1\nthis :\n ∀ {y : ℝ}, y ∈ Ico 0 1 → HasSum (fun n ↦ 1 / ↑n ^ k * (fourier n) ↑y) (-(2 * ↑π * I) ^ k / ↑k ! * ↑(bernoulliFun k y))\n⊢ -(2 * ↑π * I) ^ k / ↑k ! * ↑(bernoulliFun k 1) = -(2 * ↑π * I) ^ k / ↑k ! * ↑(bernoulliFun k 0)",
"usedConstants": [
... | rw [bernoulliFun_endpoints_eq_of_ne_one (by lia : k ≠ 1)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.LSeries.Injectivity | {
"line": 161,
"column": 6
} | {
"line": 171,
"column": 24
} | [
{
"pp": "case neg.refine_1\nf : ℕ → ℂ\nh : ¬abscissaOfAbsConv f = ⊤\nH : (fun x ↦ LSeries f ↑x) =ᶠ[atTop] 0\nF : ℕ → ℂ := fun n ↦ if n = 0 then 0 else f n\nhF₀ : F 0 = 0\nhF : ∀ {n : ℕ}, n ≠ 0 → F n = f n\nha : ¬abscissaOfAbsConv F = ⊤\nh' : ∀ (x : ℝ), LSeries F ↑x = LSeries f ↑x\nH' : ∀ (n : ℕ), (fun x ↦ ↑n ^ ... | induction n using Nat.strongRecOn with | ind n ih =>
-- it suffices to show that `n ^ x * LSeries F x` tends to `F n` as `x` tends to `∞`
suffices Tendsto (fun x : ℝ ↦ n ^ (x : ℂ) * LSeries F x) atTop (nhds (F n)) by
replace this := this.congr' <| H' n
simp only [tendsto_const_nhds_iff] at t... | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.NumberTheory.LegendreSymbol.Complex | {
"line": 30,
"column": 34
} | {
"line": 30,
"column": 56
} | [
{
"pp": "F : Type u_1\ninst✝¹ : Field F\ninst✝ : Finite F\n⊢ ringChar ℂ ≠ ringChar F",
"usedConstants": [
"_private.Mathlib.NumberTheory.LegendreSymbol.Complex.0.AddChar.ringChar_ne"
]
}
] | by exact ringChar_ne F | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.NumberTheory.LSeries.SumCoeff | {
"line": 103,
"column": 4
} | {
"line": 103,
"column": 90
} | [
{
"pp": "f : ℕ → ℂ\nhf : f 0 = 0\nr : ℝ\nhr : 0 ≤ r\ns : ℂ\nhs : r < s.re\nhS : LSeriesSummable f s\nhO : (fun n ↦ ∑ k ∈ Icc 1 n, f k) =O[atTop] fun n ↦ ↑n ^ r\n⊢ (-s - 1).re + r < -1",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"Real.partialOr... | rwa [sub_re, one_re, neg_re, neg_sub_left, neg_add_lt_iff_lt_add, add_neg_cancel_comm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas | {
"line": 100,
"column": 8
} | {
"line": 100,
"column": 27
} | [
{
"pp": "p : ℕ\nh : Fact (Nat.Prime p)\na : ℤ\nha0 : ↑a ≠ 0\nhp : Odd p\n⊢ ↑(legendreSym p a) = ↑((-1) ^ #({x ∈ Ico 1 (p / 2).succ | p / 2 < (↑a * ↑x).val}))",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOn... | legendreSym.eq_pow, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.LSeries.PrimesInAP | {
"line": 487,
"column": 2
} | {
"line": 487,
"column": 41
} | [
{
"pp": "q : ℕ\ninst✝ : NeZero q\na : ZMod q\nha : IsUnit a\nn p : ℕ\nhp₁ : p ∈ {p | Prime p ∧ ↑p = a}\nhp₂ : n < p\n⊢ ∃ p > n, Prime p ∧ ↑p = a",
"usedConstants": [
"Nat.Prime",
"Preorder.toLT",
"ZMod.commRing",
"PartialOrder.toPreorder",
"setOf",
"AddGroupWithOne.toAddM... | exact ⟨p, hp₂.gt, Set.mem_setOf.mp hp₁⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.Valuation.DiscreteValuativeRel | {
"line": 60,
"column": 6
} | {
"line": 64,
"column": 72
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝² : CommRing R\ninst✝¹ : ValuativeRel R\nv : Valuation R (WithZero (Multiplicative ℤ))\ninst✝ : v.Compatible\nthis : IsRankLeOne R\nh : IsNontrivial R\nH : DenselyOrdered (ValueGroupWithZero R)\n⊢ IsDiscrete R",
"usedConstants": [
"Int.instAddCommGroup",
"Wi... | exfalso
refine (MonoidWithZeroHom.range_nontrivial
(ValueGroupWithZero.orderMonoidIso v).toMonoidWithZeroHom).not_subsingleton ?_
rw [← WithZero.denselyOrdered_set_iff_subsingleton]
exact (ValueGroupWithZero.embed_strictMono v).denselyOrdered_range | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Valuation.DiscreteValuativeRel | {
"line": 60,
"column": 6
} | {
"line": 64,
"column": 72
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝² : CommRing R\ninst✝¹ : ValuativeRel R\nv : Valuation R (WithZero (Multiplicative ℤ))\ninst✝ : v.Compatible\nthis : IsRankLeOne R\nh : IsNontrivial R\nH : DenselyOrdered (ValueGroupWithZero R)\n⊢ IsDiscrete R",
"usedConstants": [
"Int.instAddCommGroup",
"Wi... | exfalso
refine (MonoidWithZeroHom.range_nontrivial
(ValueGroupWithZero.orderMonoidIso v).toMonoidWithZeroHom).not_subsingleton ?_
rw [← WithZero.denselyOrdered_set_iff_subsingleton]
exact (ValueGroupWithZero.embed_strictMono v).denselyOrdered_range | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | {
"line": 411,
"column": 21
} | {
"line": 411,
"column": 97
} | [
{
"pp": "a✝ b : ℕ\nha : Odd a✝\nhb : Odd b\na : ℕ\n⊢ qrSign 1 a * J(↑1 | a) = 1",
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"qrSign",
"outParam",
"HMul",
"HEq.refl",
"Nat.instMulOneClass",
"Eq.mp",
"Eq.casesOn",
"MulOne.toMul",
"Int",
... | convert! ← mul_one (M := ℤ) _; (on_goal 1 => symm); all_goals apply one_left | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | {
"line": 411,
"column": 21
} | {
"line": 411,
"column": 97
} | [
{
"pp": "a✝ b : ℕ\nha : Odd a✝\nhb : Odd b\na : ℕ\n⊢ qrSign 1 a * J(↑1 | a) = 1",
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"qrSign",
"outParam",
"HMul",
"HEq.refl",
"Nat.instMulOneClass",
"Eq.mp",
"Eq.casesOn",
"MulOne.toMul",
"Int",
... | convert! ← mul_one (M := ℤ) _; (on_goal 1 => symm); all_goals apply one_left | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | {
"line": 530,
"column": 2
} | {
"line": 530,
"column": 24
} | [
{
"pp": "case ind\na : ℕ\nIH :\n ∀ m < a,\n ∀ {b : ℕ} {flip : Bool} {ha0 : m > 0},\n b % 2 = 1 → b > 1 → fastJacobiSymAux m b flip ha0 = if flip = true then -J(↑m | b) else J(↑m | b)\nb : ℕ\nflip : Bool\nha0 : a > 0\nhb2 : b % 2 = 1\nhb1 : b > 1\n⊢ (if ha4 : a % 4 = 0 then fastJacobiSymAux (a / 4) b fl... | split <;> rename_i ha4 | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Topology.Algebra.Valued.LocallyCompact | {
"line": 146,
"column": 4
} | {
"line": 146,
"column": 22
} | [
{
"pp": "case mp.mk\nK : Type u_1\nΓ₀ : Type u_2\ninst✝⁴ : Field K\ninst✝³ : LinearOrderedCommGroupWithZero Γ₀\ninst✝² : Valued K Γ₀\ninst✝¹ : v.RankOne\ninst✝ : IsDiscreteValuationRing ↥𝒪[K]\nH : TotallyBounded Set.univ\np : ↥𝒪[K]\nhp : Irreducible p\nt : Set ↥𝒪[K]\nht : t.Finite\na✝ : IsLocalRing.ResidueFi... | refine ⟨y, hy, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.NumberTheory.MaricaSchoenheim | {
"line": 55,
"column": 4
} | {
"line": 55,
"column": 20
} | [
{
"pp": "case calc_2\nn : ℕ\nf : ℕ → ℕ\nhf' : ∀ k < n, Squarefree (f k)\nhn : n ≠ 0\nhf : StrictMonoOn f (Set.Iio n)\nthis : ∀ i < n, ∀ j < n, f i < (f i).gcd (f j) * n\n𝒜 : Finset (Finset ℕ) := image (fun n ↦ (f n).primeFactors) (Iio n)\nhf'' : ∀ i < n, ∀ (j : ℕ), Squarefree (f i / (f i).gcd (f j))\n⊢ ∀ ⦃x : ... | rintro i hi j hj | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.NumberTheory.LucasLehmer | {
"line": 473,
"column": 2
} | {
"line": 475,
"column": 14
} | [
{
"pp": "q : ℕ\ninst✝ : NeZero q\nw : 1 < q\n⊢ Fintype.card (X q)ˣ < q ^ 2",
"usedConstants": [
"LucasLehmer.X.card_eq",
"Eq.mpr",
"congrArg",
"CommSemiring.toSemiring",
"LucasLehmer.X.instNontrivialOfFactLtNatOfNat",
"HEq.refl",
"Nat.instMonoid",
"card_units_... | have : Fact (1 < (q : ℕ)) := ⟨w⟩
convert! card_units_lt (X q)
rw [card_eq] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.LucasLehmer | {
"line": 473,
"column": 2
} | {
"line": 475,
"column": 14
} | [
{
"pp": "q : ℕ\ninst✝ : NeZero q\nw : 1 < q\n⊢ Fintype.card (X q)ˣ < q ^ 2",
"usedConstants": [
"LucasLehmer.X.card_eq",
"Eq.mpr",
"congrArg",
"CommSemiring.toSemiring",
"LucasLehmer.X.instNontrivialOfFactLtNatOfNat",
"HEq.refl",
"Nat.instMonoid",
"card_units_... | have : Fact (1 < (q : ℕ)) := ⟨w⟩
convert! card_units_lt (X q)
rw [card_eq] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.LucasLehmer | {
"line": 507,
"column": 2
} | {
"line": 507,
"column": 52
} | [
{
"pp": "case h\np' : ℕ\nk : ℤ\nh : ω ^ 2 ^ p' * (ω ^ 2 ^ p' + ωb ^ 2 ^ p') = ω ^ 2 ^ p' * ↑((2 ^ (p' + 2) - 1) * k)\n⊢ ω ^ 2 ^ (p' + 1) = ↑k * ↑(mersenne (p' + 2)) * ω ^ 2 ^ p' - 1",
"usedConstants": [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWi... | have t : 2 ^ p' + 2 ^ p' = 2 ^ (p' + 1) := by ring | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.NumberTheory.MahlerMeasure | {
"line": 234,
"column": 2
} | {
"line": 234,
"column": 34
} | [
{
"pp": "case right\np : ℤ[X]\nh : (map (castRingHom ℂ) p).mahlerMeasure = 1\nhX : ¬X ∣ p\nhpdeg : p.degree ≠ 0\nhpdegC : (map (castRingHom ℂ) p).degree ≠ 0\nz : ℂ\nh✝ : eval z (map (castRingHom ℂ) p) = 0\nhz₀ : z ≠ 0\nh_z_root : z ∈ p.aroots ℂ\nm : ℕ\nh_m_pos : 0 < m\nh_prim : IsPrimitiveRoot z m\n⊢ (aeval z) ... | exact (mem_aroots.mp h_z_root).2 | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.NumberTheory.ModularForms.SlashActions | {
"line": 51,
"column": 37
} | {
"line": 51,
"column": 47
} | [
{
"pp": "β : Type u_1\nG : Type u_2\nα : Type u_3\ninst✝² : Monoid G\ninst✝¹ : AddGroup α\ninst✝ : SlashAction β G α\nk : β\ng : G\na : α\n⊢ 0 ∣[k] g = 0",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZe... | zero_slash | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.ModularForms.SlashActions | {
"line": 70,
"column": 24
} | {
"line": 70,
"column": 69
} | [
{
"pp": "β : Type u_1\nG : Type u_2\nH : Type u_3\nα : Type u_4\ninst✝³ : Monoid G\ninst✝² : AddMonoid α\ninst✝¹ : Monoid H\ninst✝ : SlashAction β G α\nh : H →* G\nk : β\ng gg : H\na : α\n⊢ a ∣[k] h (g * gg) = (a ∣[k] h g) ∣[k] h gg",
"usedConstants": [
"MonoidHom.instMonoidHomClass",
"MonoidHom... | by simp only [map_mul, SlashAction.slash_mul] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.NumberTheory.ModularForms.SlashActions | {
"line": 193,
"column": 2
} | {
"line": 193,
"column": 53
} | [
{
"pp": "k : ℤ\nf : ℍ → ℂ\nγ : SL(2, ℤ)\nz : ℍ\n⊢ f (γ • z) * denom (Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) γ)) ↑z ^ (-k) =\n f z ↔\n f (γ • z) = (↑(↑γ 1 0) * ↑z + ↑(↑γ 1 1)) ^ k * f z",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"GroupWit... | convert! inv_mul_eq_iff_eq_mul₀ (G₀ := ℂ) _ using 2 | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___macroRules_Mathlib_Tactic_convert!_1 | Mathlib.Tactic.convert! |
Mathlib.NumberTheory.ModularForms.BoundedAtCusp | {
"line": 83,
"column": 25
} | {
"line": 83,
"column": 81
} | [
{
"pp": "c : OnePoint ℝ\nf : ℍ → ℂ\nk : ℤ\ng : GL (Fin 2) ℝ\nhg : g • ∞ = c\n⊢ IsBoundedAtImInfty (f ∣[k] g) → c.IsBoundedAt f k",
"usedConstants": [
"OnePoint.instGLAction",
"OnePoint.IsBoundedAt",
"UpperHalfPlane.IsBoundedAtImInfty",
"Real",
"instHSMul",
"OnePoint.infty... | simp [← hg, IsBoundedAt.smul_iff, isBoundedAt_infty_iff] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.NumberTheory.ModularForms.BoundedAtCusp | {
"line": 83,
"column": 25
} | {
"line": 83,
"column": 81
} | [
{
"pp": "c : OnePoint ℝ\nf : ℍ → ℂ\nk : ℤ\ng : GL (Fin 2) ℝ\nhg : g • ∞ = c\n⊢ IsBoundedAtImInfty (f ∣[k] g) → c.IsBoundedAt f k",
"usedConstants": [
"OnePoint.instGLAction",
"OnePoint.IsBoundedAt",
"UpperHalfPlane.IsBoundedAtImInfty",
"Real",
"instHSMul",
"OnePoint.infty... | simp [← hg, IsBoundedAt.smul_iff, isBoundedAt_infty_iff] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.ModularForms.BoundedAtCusp | {
"line": 83,
"column": 25
} | {
"line": 83,
"column": 81
} | [
{
"pp": "c : OnePoint ℝ\nf : ℍ → ℂ\nk : ℤ\ng : GL (Fin 2) ℝ\nhg : g • ∞ = c\n⊢ IsBoundedAtImInfty (f ∣[k] g) → c.IsBoundedAt f k",
"usedConstants": [
"OnePoint.instGLAction",
"OnePoint.IsBoundedAt",
"UpperHalfPlane.IsBoundedAtImInfty",
"Real",
"instHSMul",
"OnePoint.infty... | simp [← hg, IsBoundedAt.smul_iff, isBoundedAt_infty_iff] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.ModularForms.QExpansion | {
"line": 495,
"column": 2
} | {
"line": 496,
"column": 59
} | [
{
"pp": "case h\nh : ℝ\nf g : ℍ → ℂ\nhf : AnalyticAt ℂ (cuspFunction h f) 0\nhg : AnalyticAt ℂ (cuspFunction h g) 0\nm : ℕ\n⊢ (PowerSeries.coeff m) (qExpansion h (f + g)) = (PowerSeries.coeff m) (qExpansion h f + qExpansion h g)",
"usedConstants": [
"Distrib.leftDistribClass",
"InnerProductSpace... | simp [qExpansion_coeff, cuspFunction_add hf.continuousAt hg.continuousAt,
iteratedDeriv_add hf.contDiffAt hg.contDiffAt, mul_add] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.NumberTheory.ModularForms.QExpansion | {
"line": 519,
"column": 59
} | {
"line": 528,
"column": 45
} | [
{
"pp": "h : ℝ\n⊢ qExpansion h 1 = 1",
"usedConstants": [
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Real",
"Semiring.toModule",
"InvOneClass.toOne",
"HMul.hMul",
"Divis... | by
ext m
have h1 : cuspFunction h 1 = 1 := by
ext q
rcases eq_or_ne q 0 with rfl | hq
· simpa [cuspFunction, Periodic.cuspFunction] using tendsto_const_nhds.limUnder_eq
· simp [cuspFunction, Periodic.cuspFunction_eq_of_nonzero h _ hq]
have h2 : iteratedDeriv m (1 : ℂ → ℂ) 0 = if m = 0 then 1 else ... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.NumberTheory.ModularForms.Bounds | {
"line": 89,
"column": 2
} | {
"line": 96,
"column": 50
} | [
{
"pp": "case pos\nE : Type u_1\ninst✝ : SeminormedAddCommGroup E\nf : ℍ → E\nhf_cont : Continuous[_, PseudoMetricSpace.toUniformSpace.toTopologicalSpace] f\nt : ℝ\nht : 0 ≤ t\nhf_infinity : f =O[atImInfty] fun z ↦ z.im ^ t\nhf_inv : ∀ (g : SL(2, ℤ)) (τ : ℍ), f (g • τ) = f τ\nF : ℝ\nτ : ℍ\ng : SL(2, ℤ)\nhg✝ : g... | · -- If `c = 0`, then `(g • τ).im = τ.im / d ^ 2` and `d ^ 2 ≥ 1`.
-- (In fact `d = ±1`, but we do not need this stronger statement).
have : g 1 1 ≠ 0 := fun hg' ↦ zero_ne_one <| by
simpa only [Matrix.det_fin_two, hg, hg', mul_zero, mul_zero, sub_zero] using g.det_coe
have : (1 : ℝ) ≤ g 1 1 ^ 2 := mod... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.NumberTheory.ModularForms.Bounds | {
"line": 103,
"column": 65
} | {
"line": 103,
"column": 92
} | [
{
"pp": "E : Type u_1\ninst✝ : SeminormedAddCommGroup E\nf : ℍ → E\nhf_cont : Continuous[_, PseudoMetricSpace.toUniformSpace.toTopologicalSpace] f\nt : ℝ\nht : 0 ≤ t\nhf_infinity : f =O[atImInfty] fun z ↦ z.im ^ t\nhf_inv : ∀ (g : SL(2, ℤ)) (τ : ℍ), f (g • τ) = f τ\nF : ℝ\nτ : ℍ\ng : SL(2, ℤ)\nhg✝ : g • τ ∈ 𝒟\... | simp [Complex.normSq_apply] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | {
"line": 82,
"column": 4
} | {
"line": 82,
"column": 34
} | [
{
"pp": "z : ℍ\nthis :\n ∑' (n : ℕ) (c : ℕ+), ↑↑c ^ 1 * cexp (2 * ↑π * I * ↑z) ^ ((n + 1) * ↑c) =\n ∑' (e : ℕ+), ↑((σ 1) ↑e) * cexp (2 * ↑π * I * ↑z) ^ ↑e\n⊢ -8 * ↑π ^ 2 * ∑' (n : ℕ+), ↑((σ 1) ↑n) * cexp (2 * ↑π * I * ↑z) ^ ↑n =\n ∑' (m : ℕ), -8 * ↑π ^ 2 * ∑' (n : ℕ+), ↑↑n * cexp (2 * ↑π * I * ↑z) ^ ((m ... | simp [← tsum_mul_left, ← this] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform | {
"line": 195,
"column": 2
} | {
"line": 195,
"column": 82
} | [
{
"pp": "case h\nz : ℍ\n⊢ G2 (1 +ᵥ z) *\n denom (Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) T)) ↑z ^ (-2) =\n G2 z",
"usedConstants": [
"PNat.val",
"AddGroup.toSubtractionMonoid",
"Int.cast",
"Eq.mpr",
"NormedCommRing.toSeminorme... | simp [G2_eq_tsum_cexp, T, denom_apply, ← exp_periodic.nat_mul 1 (2 * π * I * z)] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform | {
"line": 225,
"column": 2
} | {
"line": 226,
"column": 54
} | [
{
"pp": "γ : SL(2, ℤ)\n⊢ E2 ∣[2] γ = E2 - (1 / (2 * riemannZeta 2)) • D2 γ",
"usedConstants": [
"MulOne.toOne",
"DivInvMonoid.toInv",
"instHSMul",
"Matrix.SpecialLinearGroup",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"instSMulOfMul",
"HMul.... | ext z
simp [E2, SL_smul_slash, G2_slash_action γ, mul_sub] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform | {
"line": 225,
"column": 2
} | {
"line": 226,
"column": 54
} | [
{
"pp": "γ : SL(2, ℤ)\n⊢ E2 ∣[2] γ = E2 - (1 / (2 * riemannZeta 2)) • D2 γ",
"usedConstants": [
"MulOne.toOne",
"DivInvMonoid.toInv",
"instHSMul",
"Matrix.SpecialLinearGroup",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"instSMulOfMul",
"HMul.... | ext z
simp [E2, SL_smul_slash, G2_slash_action γ, mul_sub] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.ModularForms.Derivative | {
"line": 44,
"column": 2
} | {
"line": 44,
"column": 28
} | [
{
"pp": "F : ℍ → ℂ\nhF : DifferentiableOn ℂ (F ∘ ↑ofComplex) {z | 0 < z.im}\n⊢ DifferentiableOn ℂ (D F ∘ ↑ofComplex) {z | 0 < z.im}",
"usedConstants": [
"Real.pi",
"HMul.hMul",
"Nat.instAtLeastTwoHAddOfNat",
"Complex.instMul",
"instOfNatNat",
"Complex.instNatCast",
... | let c : ℂ := (2 * π * I)⁻¹ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | {
"line": 262,
"column": 4
} | {
"line": 262,
"column": 90
} | [
{
"pp": "case hg\nz : ℍ\nthis :\n ∀ (N : ℕ+),\n ∑ n ∈ Ico (-↑↑N) ↑↑N, ∑' (m : ℤ), (1 / (↑m * ↑z + ↑n) - 1 / (↑m * ↑z + ↑n + 1)) =\n -(2 / ↑↑N) +\n ∑' (m : ℕ+), (1 / (↑↑m * ↑z - ↑↑N) + 1 / (-↑↑m * ↑z + -↑↑N) - 1 / (↑↑m * ↑z + ↑↑N) - 1 / (-↑↑m * ↑z + ↑↑N))\n⊢ Tendsto\n (fun x ↦\n ∑' (m : ℕ... | simpa only [aux_tsum_identity_2, ← PNat.tendsto_comp_val_iff] using aux_tendsto_tsum z | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | {
"line": 262,
"column": 4
} | {
"line": 262,
"column": 90
} | [
{
"pp": "case hg\nz : ℍ\nthis :\n ∀ (N : ℕ+),\n ∑ n ∈ Ico (-↑↑N) ↑↑N, ∑' (m : ℤ), (1 / (↑m * ↑z + ↑n) - 1 / (↑m * ↑z + ↑n + 1)) =\n -(2 / ↑↑N) +\n ∑' (m : ℕ+), (1 / (↑↑m * ↑z - ↑↑N) + 1 / (-↑↑m * ↑z + -↑↑N) - 1 / (↑↑m * ↑z + ↑↑N) - 1 / (-↑↑m * ↑z + ↑↑N))\n⊢ Tendsto\n (fun x ↦\n ∑' (m : ℕ... | simpa only [aux_tsum_identity_2, ← PNat.tendsto_comp_val_iff] using aux_tendsto_tsum z | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | {
"line": 262,
"column": 4
} | {
"line": 262,
"column": 90
} | [
{
"pp": "case hg\nz : ℍ\nthis :\n ∀ (N : ℕ+),\n ∑ n ∈ Ico (-↑↑N) ↑↑N, ∑' (m : ℤ), (1 / (↑m * ↑z + ↑n) - 1 / (↑m * ↑z + ↑n + 1)) =\n -(2 / ↑↑N) +\n ∑' (m : ℕ+), (1 / (↑↑m * ↑z - ↑↑N) + 1 / (-↑↑m * ↑z + -↑↑N) - 1 / (↑↑m * ↑z + ↑↑N) - 1 / (-↑↑m * ↑z + ↑↑N))\n⊢ Tendsto\n (fun x ↦\n ∑' (m : ℕ... | simpa only [aux_tsum_identity_2, ← PNat.tendsto_comp_val_iff] using aux_tendsto_tsum z | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Modular | {
"line": 867,
"column": 8
} | {
"line": 867,
"column": 44
} | [
{
"pp": "x : ℍ\nhxnorm : 1 < ‖↑x‖\nhxre : |x.re| ≤ 1 / 2\n⊢ ↑1 * ↑x ∈ ofComplex.source",
"usedConstants": [
"UpperHalfPlane.ofComplex",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"UpperHalfPlane.isOpenEmbedding_coe",
"Real",
"HMul.hMul",
"UpperHalfPlane.coe",
... | simpa [ofComplex] using x.coe_im_pos | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.NumberTheory.ModularForms.Discriminant | {
"line": 77,
"column": 2
} | {
"line": 92,
"column": 12
} | [
{
"pp": "z : ℍ\n⊢ logDeriv (η ∘ fun x ↦ -1 / x) ↑z = logDeriv (sqrt * η) ↑z",
"usedConstants": [
"logDeriv",
"NormedCommRing.toNormedRing",
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Mathlib.Tactic.FieldSimp.zpow'_one",
"Int.cast",
"Mathlib.Tactic.Field... | rw [logDeriv_eta_comp_div_eq z, Pi.mul_def,
logDeriv_mul _ (by simp [sqrt, ne_zero z]) (eta_ne_zero z.2)
(differentiableAt_sqrt (mem_slitPlane z))
(differentiableAt_eta_of_mem_upperHalfPlaneSet z.2), logDeriv_apply sqrt]
have hE2 := congrFun (E2_slash_action ModularGroup.S) z
simp only [one_div, S... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.ModularForms.Discriminant | {
"line": 77,
"column": 2
} | {
"line": 92,
"column": 12
} | [
{
"pp": "z : ℍ\n⊢ logDeriv (η ∘ fun x ↦ -1 / x) ↑z = logDeriv (sqrt * η) ↑z",
"usedConstants": [
"logDeriv",
"NormedCommRing.toNormedRing",
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Mathlib.Tactic.FieldSimp.zpow'_one",
"Int.cast",
"Mathlib.Tactic.Field... | rw [logDeriv_eta_comp_div_eq z, Pi.mul_def,
logDeriv_mul _ (by simp [sqrt, ne_zero z]) (eta_ne_zero z.2)
(differentiableAt_sqrt (mem_slitPlane z))
(differentiableAt_eta_of_mem_upperHalfPlaneSet z.2), logDeriv_apply sqrt]
have hE2 := congrFun (E2_slash_action ModularGroup.S) z
simp only [one_div, S... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | {
"line": 207,
"column": 49
} | {
"line": 207,
"column": 77
} | [
{
"pp": "k : ℕ\nhk : 1 ≤ k\nz : ℍ\n⊢ (-2 * ↑π * I) ^ (k + 1) / ↑k ! * ∑' (n : ℕ), ↑n ^ k * cexp (2 * ↑π * I * ↑z) ^ n =\n (-2 * ↑π * I) ^ (k + 1) / ↑k ! * ∑' (n : ℕ+), ↑↑n ^ k * cexp (2 * ↑π * I * ↑z) ^ ↑n",
"usedConstants": [
"PNat.val",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",... | ← tsum_zero_pnat_eq_tsum_nat | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Algebra.Group.DiscontinuousSubgroup | {
"line": 84,
"column": 2
} | {
"line": 89,
"column": 66
} | [
{
"pp": "Γ : Type u_1\nα : Type u_2\ninst✝³ : Group Γ\ninst✝² : TopologicalSpace α\ninst✝¹ : MulAction Γ α\ninst✝ : ContinuousConstSMul Γ α\nG H : Subgroup Γ\nh : G.Commensurable H\n⊢ ProperlyDiscontinuousSMul (↥G) α ↔ ProperlyDiscontinuousSMul (↥H) α",
"usedConstants": [
"Subgroup.inf_relIndex_left",... | have : IsFiniteRelIndex (G ⊓ H) H := ⟨Subgroup.inf_relIndex_right G H ▸ h.1⟩
have : IsFiniteRelIndex (G ⊓ H) G := ⟨Subgroup.inf_relIndex_left G H ▸ h.2⟩
calc ProperlyDiscontinuousSMul G α ↔ ProperlyDiscontinuousSMul ↑(G ⊓ H) α :=
(properlyDiscontinuousSMul_iff_of_isFiniteRelIndex inf_le_left).symm
_ ↔ Properl... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Algebra.Group.DiscontinuousSubgroup | {
"line": 84,
"column": 2
} | {
"line": 89,
"column": 66
} | [
{
"pp": "Γ : Type u_1\nα : Type u_2\ninst✝³ : Group Γ\ninst✝² : TopologicalSpace α\ninst✝¹ : MulAction Γ α\ninst✝ : ContinuousConstSMul Γ α\nG H : Subgroup Γ\nh : G.Commensurable H\n⊢ ProperlyDiscontinuousSMul (↥G) α ↔ ProperlyDiscontinuousSMul (↥H) α",
"usedConstants": [
"Subgroup.inf_relIndex_left",... | have : IsFiniteRelIndex (G ⊓ H) H := ⟨Subgroup.inf_relIndex_right G H ▸ h.1⟩
have : IsFiniteRelIndex (G ⊓ H) G := ⟨Subgroup.inf_relIndex_left G H ▸ h.2⟩
calc ProperlyDiscontinuousSMul G α ↔ ProperlyDiscontinuousSMul ↑(G ⊓ H) α :=
(properlyDiscontinuousSMul_iff_of_isFiniteRelIndex inf_le_left).symm
_ ↔ Properl... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | {
"line": 264,
"column": 8
} | {
"line": 264,
"column": 29
} | [
{
"pp": "case pos\nι : Type u_1\nR : ι → Type u_2\nA : (i : ι) → Set (R i)\ninst✝¹ : (i : ι) → TopologicalSpace (R i)\nS : Set ι\ninst✝ : ∀ (i : ι), WeaklyLocallyCompactSpace (R i)\nhS : Sᶜ.Finite\nhAcompact : ∀ i ∈ S, IsCompact (A i)\nx : Πʳ (i : ι), [R i, A i]_[𝓟 S]\nK : (i : ι) → Set (R i)\nK_compact : ∀ (i... | exact hAcompact i his | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | {
"line": 264,
"column": 8
} | {
"line": 264,
"column": 29
} | [
{
"pp": "case pos\nι : Type u_1\nR : ι → Type u_2\nA : (i : ι) → Set (R i)\ninst✝¹ : (i : ι) → TopologicalSpace (R i)\nS : Set ι\ninst✝ : ∀ (i : ι), WeaklyLocallyCompactSpace (R i)\nhS : Sᶜ.Finite\nhAcompact : ∀ i ∈ S, IsCompact (A i)\nx : Πʳ (i : ι), [R i, A i]_[𝓟 S]\nK : (i : ι) → Set (R i)\nK_compact : ∀ (i... | exact hAcompact i his | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | {
"line": 264,
"column": 8
} | {
"line": 264,
"column": 29
} | [
{
"pp": "case pos\nι : Type u_1\nR : ι → Type u_2\nA : (i : ι) → Set (R i)\ninst✝¹ : (i : ι) → TopologicalSpace (R i)\nS : Set ι\ninst✝ : ∀ (i : ι), WeaklyLocallyCompactSpace (R i)\nhS : Sᶜ.Finite\nhAcompact : ∀ i ∈ S, IsCompact (A i)\nx : Πʳ (i : ι), [R i, A i]_[𝓟 S]\nK : (i : ι) → Set (R i)\nK_compact : ∀ (i... | exact hAcompact i his | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | {
"line": 414,
"column": 4
} | {
"line": 414,
"column": 71
} | [
{
"pp": "ι : Type u_1\nR : ι → Type u_2\nA : (i : ι) → Set (R i)\ninst✝¹ : (i : ι) → TopologicalSpace (R i)\nhAopen : ∀ (i : ι), IsOpen[inst✝¹ i] (A i)\ninst✝ : ∀ (i : ι), WeaklyLocallyCompactSpace (R i)\nhAcompact : ∀ᶠ (i : ι) in cofinite, IsCompact (A i)\nx : Πʳ (i : ι), [R i, A i]\nS : Set ι := {i | IsCompac... | rcases exists_inclusion_eq_of_eventually R A hS hSx with ⟨x', hxx'⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.NumberTheory.NumberField.Units.Regulator | {
"line": 135,
"column": 14
} | {
"line": 135,
"column": 32
} | [
{
"pp": "K : Type u_1\ninst✝¹ : Field K\ninst✝ : NumberField K\nu : Fin (rank K) → (𝓞 K)ˣ\nh₁ :\n (Subgroup.closure (Set.range u) ⊔ torsion K).index ≠ 0 ↔\n Finite\n (↥(unitLattice K) ⧸ span ℤ (Set.range (⇑(logEmbeddingEquiv K) ∘ ⇑Additive.toMul.symm ∘ QuotientGroup.mk ∘ u)))\nh₂ : DiscreteTopology ↥(... | ← Set.range_comp', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | {
"line": 426,
"column": 4
} | {
"line": 433,
"column": 82
} | [
{
"pp": "case h.refine_2\nK : Type u_1\ninst✝ : Field K\nA : Set (mixedSpace K)\nhA : normAtAllPlaces ⁻¹' normAtAllPlaces '' A = A\nx : realSpace K\n⊢ x ∈ normAtComplexPlaces '' plusPart A → x ∈ normAtAllPlaces '' A ∩ ⋂ w, {x | x ↑w ≠ 0}",
"usedConstants": [
"Iff.mpr",
"Norm.norm",
"Eq.mpr... | rintro ⟨a, ⟨ha₁, ha₂⟩, rfl⟩
refine ⟨⟨a, ha₁, funext fun w ↦ ?_⟩, Set.mem_iInter.mpr fun w ↦ ?_⟩
· obtain hw | hw := isReal_or_isComplex w
· simpa [normAtComplexPlaces_apply_isReal ⟨w, hw⟩, normAtPlace_apply_of_isReal hw]
using (ha₂ ⟨w, hw⟩).le
· rw [normAtAllPlaces_apply, normAtPlace_apply... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | {
"line": 426,
"column": 4
} | {
"line": 433,
"column": 82
} | [
{
"pp": "case h.refine_2\nK : Type u_1\ninst✝ : Field K\nA : Set (mixedSpace K)\nhA : normAtAllPlaces ⁻¹' normAtAllPlaces '' A = A\nx : realSpace K\n⊢ x ∈ normAtComplexPlaces '' plusPart A → x ∈ normAtAllPlaces '' A ∩ ⋂ w, {x | x ↑w ≠ 0}",
"usedConstants": [
"Iff.mpr",
"Norm.norm",
"Eq.mpr... | rintro ⟨a, ⟨ha₁, ha₂⟩, rfl⟩
refine ⟨⟨a, ha₁, funext fun w ↦ ?_⟩, Set.mem_iInter.mpr fun w ↦ ?_⟩
· obtain hw | hw := isReal_or_isComplex w
· simpa [normAtComplexPlaces_apply_isReal ⟨w, hw⟩, normAtPlace_apply_of_isReal hw]
using (ha₂ ⟨w, hw⟩).le
· rw [normAtAllPlaces_apply, normAtPlace_apply... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.NumberField.CMField | {
"line": 214,
"column": 4
} | {
"line": 214,
"column": 72
} | [
{
"pp": "case refine_1\nK : Type u_1\ninst✝³ : Field K\ninst✝² : CharZero K\ninst✝¹ : IsCMField K\ninst✝ : Algebra.IsIntegral ℚ K\nx : 𝓞 K\nh : ↑x ∈ K⁺\nthis : IsIntegral ℤ ⟨↑x, h⟩\n⊢ (algebraMap (𝓞 ↥K⁺) K) ⟨⟨↑x, h⟩, this⟩ = ↑x",
"usedConstants": [
"Subalgebra.instSetLike",
"Eq.mpr",
"Su... | rw [IsScalarTower.algebraMap_apply (𝓞 K⁺) K⁺, RingOfIntegers.map_mk] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Polynomial.Cyclotomic.Factorization | {
"line": 39,
"column": 50
} | {
"line": 39,
"column": 72
} | [
{
"pp": "K : Type u_1\ninst✝¹ : Field K\ninst✝ : Fintype K\np f : ℕ\nhK : Fintype.card K = p ^ f\nh0 : f = 0\n⊢ Fintype.card K ≤ 1",
"usedConstants": [
"MulOne.toOne",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instMonoid",
"Preorder.toLE",
"Eq.mp",
"Fintype.card",
... | simpa [h0] using hK.le | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.RingTheory.Polynomial.Cyclotomic.Factorization | {
"line": 39,
"column": 50
} | {
"line": 39,
"column": 72
} | [
{
"pp": "K : Type u_1\ninst✝¹ : Field K\ninst✝ : Fintype K\np f : ℕ\nhK : Fintype.card K = p ^ f\nh0 : f = 0\n⊢ Fintype.card K ≤ 1",
"usedConstants": [
"MulOne.toOne",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instMonoid",
"Preorder.toLE",
"Eq.mp",
"Fintype.card",
... | simpa [h0] using hK.le | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Polynomial.Cyclotomic.Factorization | {
"line": 39,
"column": 50
} | {
"line": 39,
"column": 72
} | [
{
"pp": "K : Type u_1\ninst✝¹ : Field K\ninst✝ : Fintype K\np f : ℕ\nhK : Fintype.card K = p ^ f\nh0 : f = 0\n⊢ Fintype.card K ≤ 1",
"usedConstants": [
"MulOne.toOne",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instMonoid",
"Preorder.toLE",
"Eq.mp",
"Fintype.card",
... | simpa [h0] using hK.le | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | {
"line": 748,
"column": 2
} | {
"line": 748,
"column": 47
} | [
{
"pp": "K : Type u_1\ninst✝¹ : Field K\ninst✝ : NumberField K\nx : realSpace K\nhx₀ : x ≠ 0\nhx₁ : x ∈ compactSet K\n⊢ x ∈ ↑expMapBasis '' closure (paramSet K)",
"usedConstants": []
}
] | obtain ⟨c, hc, ⟨_, ⟨y, hy, rfl⟩, rfl⟩⟩ := hx₁ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.RingTheory.Unramified.Dedekind | {
"line": 27,
"column": 4
} | {
"line": 47,
"column": 85
} | [
{
"pp": "A : Type u_1\nB : Type u_2\ninst✝⁶ : CommRing A\ninst✝⁵ : CommRing B\ninst✝⁴ : Algebra A B\ninst✝³ : Module.Finite A B\ninst✝² : IsDedekindDomain A\ninst✝¹ : IsDomain B\ninst✝ : Algebra.FormallyUnramified A B\n⊢ ∀ (P : Ideal B), P ≠ ⊥ → ∀ (x : P.IsPrime), IsDiscreteValuationRing (Localization.AtPrime P... | intro q hq hqp
let q' := IsLocalRing.maximalIdeal (Localization.AtPrime q)
suffices q'.IsPrincipal from ((IsDiscreteValuationRing.TFAE (Localization.AtPrime q)
(IsLocalization.AtPrime.not_isField B hq (Localization.AtPrime q))).out 4 0).mp this
let p := q.under A
let := Localization.AtPrime.algebr... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Unramified.Dedekind | {
"line": 27,
"column": 4
} | {
"line": 47,
"column": 85
} | [
{
"pp": "A : Type u_1\nB : Type u_2\ninst✝⁶ : CommRing A\ninst✝⁵ : CommRing B\ninst✝⁴ : Algebra A B\ninst✝³ : Module.Finite A B\ninst✝² : IsDedekindDomain A\ninst✝¹ : IsDomain B\ninst✝ : Algebra.FormallyUnramified A B\n⊢ ∀ (P : Ideal B), P ≠ ⊥ → ∀ (x : P.IsPrime), IsDiscreteValuationRing (Localization.AtPrime P... | intro q hq hqp
let q' := IsLocalRing.maximalIdeal (Localization.AtPrime q)
suffices q'.IsPrincipal from ((IsDiscreteValuationRing.TFAE (Localization.AtPrime q)
(IsLocalization.AtPrime.not_isField B hq (Localization.AtPrime q))).out 4 0).mp this
let p := q.under A
let := Localization.AtPrime.algebr... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | {
"line": 247,
"column": 2
} | {
"line": 247,
"column": 59
} | [
{
"pp": "m p : ℕ\nhp : Fact (Nat.Prime p)\nK : Type u_1\ninst✝² : Field K\ninst✝¹ : NumberField K\nP : Ideal (𝓞 K)\nhP₁ : P.IsPrime\nhP₂ : P.LiesOver 𝒑\ninst✝ : NeZero m\nhK : IsCyclotomicExtension {m} ℚ K\nhm : p.Coprime m\nζ : 𝓞 K := ⋯.toInteger\nh₁ : ¬p ∣ exponent ζ\nh₂ : ↑((primesOverSpanEquivMonicFactor... | simp only [Subtype.coe_eta, Equiv.symm_apply_apply] at h₃ | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | {
"line": 268,
"column": 2
} | {
"line": 268,
"column": 59
} | [
{
"pp": "m p : ℕ\nhp : Fact (Nat.Prime p)\nK : Type u_1\ninst✝² : Field K\ninst✝¹ : NumberField K\nP : Ideal (𝓞 K)\nhP₁ : P.IsPrime\nhP₂ : P.LiesOver 𝒑\ninst✝ : NeZero m\nhK : IsCyclotomicExtension {m} ℚ K\nhm : ¬p ∣ m\nζ : 𝓞 K := ⋯.toInteger\nh₁ : ¬p ∣ exponent ζ\nh₂ : ↑((primesOverSpanEquivMonicFactorsMod ... | simp only [Subtype.coe_eta, Equiv.symm_apply_apply] at h₃ | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | {
"line": 344,
"column": 4
} | {
"line": 344,
"column": 83
} | [
{
"pp": "n m p k : ℕ\nhp : Fact (Nat.Prime p)\nK : Type u_1\ninst✝² : Field K\ninst✝¹ : NumberField K\ninst✝ : IsCyclotomicExtension {n} ℚ K\nhn : n = p ^ (k + 1) * m\nhm : ¬p ∣ m\nthis✝³ : IsAbelianGalois ℚ K\nthis✝² : NeZero m\nthis✝¹ : NeZero n\nhp' : 𝒑 ≠ ⊥\nζ : K := zeta n ℚ K\nhζ : IsPrimitiveRoot (zeta n... | ← ncard_primesOver_mul_ramificationIdxIn_mul_inertiaDegIn hp' (𝓞 Fₘ) Gal(Fₘ/ℚ), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.Padics.ProperSpace | {
"line": 46,
"column": 2
} | {
"line": 52,
"column": 91
} | [
{
"pp": "p : ℕ\ninst✝ : Fact (Nat.Prime p)\n⊢ TotallyBounded Set.univ",
"usedConstants": [
"Iff.mpr",
"NormedCommRing.toNormedRing",
"Norm.norm",
"Eq.mpr",
"TotallyBounded",
"NormedCommRing.toSeminormedCommRing",
"Finite.Set.finite_image",
"Real.instLE",
... | refine Metric.totallyBounded_iff.mpr (fun ε hε ↦ ?_)
obtain ⟨k, hk⟩ := exists_pow_neg_lt p hε
refine ⟨Nat.cast '' Finset.range (p ^ k), Set.toFinite _, fun z _ ↦ ?_⟩
simp only [PadicInt, Set.mem_iUnion, Metric.mem_ball, exists_prop, Set.exists_mem_image]
refine ⟨z.appr k, ?_, ?_⟩
· simpa only [Finset.mem_coe,... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Padics.ProperSpace | {
"line": 46,
"column": 2
} | {
"line": 52,
"column": 91
} | [
{
"pp": "p : ℕ\ninst✝ : Fact (Nat.Prime p)\n⊢ TotallyBounded Set.univ",
"usedConstants": [
"Iff.mpr",
"NormedCommRing.toNormedRing",
"Norm.norm",
"Eq.mpr",
"TotallyBounded",
"NormedCommRing.toSeminormedCommRing",
"Finite.Set.finite_image",
"Real.instLE",
... | refine Metric.totallyBounded_iff.mpr (fun ε hε ↦ ?_)
obtain ⟨k, hk⟩ := exists_pow_neg_lt p hε
refine ⟨Nat.cast '' Finset.range (p ^ k), Set.toFinite _, fun z _ ↦ ?_⟩
simp only [PadicInt, Set.mem_iUnion, Metric.mem_ball, exists_prop, Set.exists_mem_image]
refine ⟨z.appr k, ?_, ?_⟩
· simpa only [Finset.mem_coe,... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.NumberField.House | {
"line": 84,
"column": 2
} | {
"line": 84,
"column": 20
} | [
{
"pp": "K : Type u_1\ninst✝¹ : Field K\ninst✝ : NumberField K\nα : K\nσ : K →+* ℂ\n⊢ ‖σ α‖ ≤ house α",
"usedConstants": [
"Norm.norm",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"Real.instLE",
"Real",
"Finset.univ",
"congrArg",
"SeminormedAddGroup.toNNN... | rw [house_eq_sup'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.NumberTheory.Ostrowski | {
"line": 68,
"column": 60
} | {
"line": 68,
"column": 77
} | [
{
"pp": "T : Type u_1\nF : Type u_2\ninst✝ : DivisionRing F\nl : List T\ny : F\nhy : y ≠ 1\n⊢ (List.map\n (fun x ↦\n match x with\n | (a, i) => y ^ i)\n l.zipIdx).sum =\n ∑ i ∈ Finset.range l.length, y ^ i",
"usedConstants": [
"Eq.mpr",
"Finset.univ",
"Ri... | Finset.sum_range, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.Ostrowski | {
"line": 474,
"column": 2
} | {
"line": 474,
"column": 21
} | [
{
"pp": "p : ℕ\ninst✝ : Fact (Nat.Prime p)\n⊢ ¬∃ c, 0 < c ∧ (fun x ↦ real x ^ c) = ⇑(padic p)",
"usedConstants": [
"Real.instPow",
"Real.partialOrder",
"Real",
"Real.instZero",
"Rat",
"Rat.AbsoluteValue.real",
"Real.instLT",
"Exists",
"Real.semiring",
... | rintro ⟨c, hc₀, hc⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.NumberTheory.Padics.MahlerBasis | {
"line": 236,
"column": 4
} | {
"line": 236,
"column": 91
} | [
{
"pp": "case inr\np : ℕ\nhp : Fact (Nat.Prime p)\nE : Type u_1\ninst✝³ : NormedAddCommGroup E\ninst✝² : Module ℤ_[p] E\ninst✝¹ : IsBoundedSMul ℤ_[p] E\ninst✝ : IsUltrametricDist E\nf : C(ℤ_[p], E)\nε : ℝ\nhε : ε > 0\nthis : Tendsto (fun s ↦ ‖f‖ / ↑p ^ s) atTop (𝓝 0)\ns : ℕ\nhs : ‖f‖ / ↑p ^ s < ε\nhf : f ≠ 0\n... | have : 0 < ‖f‖ / p ^ s := div_pos (norm_pos_iff.mpr hf) (mod_cast pow_pos hp.out.pos _) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.NumberTheory.Padics.MahlerBasis | {
"line": 262,
"column": 2
} | {
"line": 264,
"column": 100
} | [
{
"pp": "case a\np : ℕ\nhp : Fact (Nat.Prime p)\nE : Type u_1\ninst✝² : NormedAddCommGroup E\ninst✝¹ : Module ℤ_[p] E\ninst✝ : IsBoundedSMul ℤ_[p] E\na : E\nn : ℕ\n⊢ ‖mahlerTerm a n‖ ≤ ‖a‖",
"usedConstants": [
"norm_smul_le",
"AddGroup.toSubtractionMonoid",
"Real.instIsOrderedRing",
... | · -- Show all values have norm ≤ 1
rw [ContinuousMap.norm_le_of_nonempty]
refine fun _ ↦ (norm_smul_le _ _).trans <| mul_le_of_le_one_left (norm_nonneg _) (norm_le_one _) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.NumberTheory.Padics.MahlerBasis | {
"line": 267,
"column": 4
} | {
"line": 267,
"column": 46
} | [
{
"pp": "case a\np : ℕ\nhp : Fact (Nat.Prime p)\nE : Type u_1\ninst✝² : NormedAddCommGroup E\ninst✝¹ : Module ℤ_[p] E\ninst✝ : IsBoundedSMul ℤ_[p] E\na : E\nn : ℕ\n⊢ ‖a‖ ≤ ‖(mahlerTerm a n) ↑n‖",
"usedConstants": [
"NormedCommRing.toNormedRing",
"Norm.norm",
"NormedCommRing.toSeminormedCom... | simp [mahlerTerm_apply, mahler_natCast_eq] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.NumberTheory.Pell | {
"line": 253,
"column": 79
} | {
"line": 256,
"column": 54
} | [
{
"pp": "d : ℤ\na : Solution₁ d\nhax : 0 < a.x\nn : ℕ\n⊢ 0 < (a ^ n).x",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Nat.recAux",
"HMul.hMul",
"instConditionallyCompleteLinearOrder",
"Int.instNeZeroOfNatOfNat",
"Monoid.toMulOneClass",
"congrArg",
"pow_... | by
induction n with
| zero => simp only [pow_zero, x_one, zero_lt_one]
| succ n ih => rw [pow_succ]; exact x_mul_pos ih hax | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.NumberTheory.Pell | {
"line": 374,
"column": 13
} | {
"line": 374,
"column": 16
} | [
{
"pp": "d : ℤ\nh₀ : 0 < d\nhd : ¬IsSquare d\nξ : ℝ := √↑d\nhξ : Irrational ξ\nM : ℤ\nhM₁ : 2 * |ξ| + 1 < ↑M\nhM : {q | |q.num ^ 2 - d * ↑q.den ^ 2| < M}.Infinite\nm : ℤ\nhm : {q | q.num ^ 2 - d * ↑q.den ^ 2 = m}.Infinite\nhm₀ : m ≠ 0\nthis : NeZero m.natAbs\nf : ℚ → ZMod m.natAbs × ZMod m.natAbs := fun q ↦ (↑q... | hq2 | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.Pell | {
"line": 490,
"column": 44
} | {
"line": 490,
"column": 56
} | [
{
"pp": "d : ℤ\na : Solution₁ d\nh : IsFundamental a\nn : ℤ\nhn : 0 ≤ n\n⊢ 1 ≤ a.x",
"usedConstants": [
"instConditionallyCompleteLinearOrder",
"PartialOrder.toPreorder",
"Pell.Solution₁.x",
"LT.lt.le",
"Int",
"LE.le",
"ConditionallyCompleteLinearOrder.toConditional... | exact h.1.le | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.NumberTheory.Pell | {
"line": 510,
"column": 95
} | {
"line": 512,
"column": 87
} | [
{
"pp": "d : ℤ\na : Solution₁ d\nh : IsFundamental a\nn : ℤ\n⊢ a ^ n = 1 ↔ n = 0",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"InvOneClass.toOne",
"instConditionallyCompleteLinearOrder",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"Mono... | by
rw [← zpow_zero a]
exact ⟨fun H => h.y_strictMono.injective (congr_arg Solution₁.y H), fun H => H ▸ rfl⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.NumberTheory.Pell | {
"line": 537,
"column": 2
} | {
"line": 537,
"column": 20
} | [
{
"pp": "d : ℤ\na₁ : Solution₁ d\nh : IsFundamental a₁\na : Solution₁ d\nhax : 1 < a.x\nhay : 0 < a.y\nH : d * (a₁.y ^ 2 - a.y ^ 2) = a₁.x ^ 2 - a.x ^ 2\n⊢ a₁.x ≤ a.x",
"usedConstants": [
"Pell.IsFundamental.x_le_x"
]
}
] | exact h.x_le_x hax | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.NumberTheory.Pell | {
"line": 617,
"column": 2
} | {
"line": 617,
"column": 36
} | [
{
"pp": "case inr.inr.inl\nd : ℤ\na₁ : Solution₁ d\nh : IsFundamental a₁\nb : Solution₁ d\nhbx : 0 < b.x\nhby : 0 ≤ b.y\nn : ℕ\nhn : b = a₁ ^ n\n⊢ ∃ n, -b = a₁ ^ n ∨ -b = -a₁ ^ n",
"usedConstants": [
"zpow_natCast",
"Monoid.toMulOneClass",
"congrArg",
"DivInvMonoid.toZPow",
"Mu... | · exact ⟨n, Or.inr (by simp [hn])⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.NumberTheory.Rayleigh | {
"line": 110,
"column": 2
} | {
"line": 114,
"column": 67
} | [
{
"pp": "case inr\nr : ℝ\nj : ℤ\nh : r > 0\nh✝ : ↑j < ↑⌊(↑j + 1) / r⌋ * r\n⊢ j ∈ {x | ∃ k, beattySeq' r k = x} ∨ ∃ k, ↑k ≤ ↑j / r ∧ (↑j + 1) / r < ↑k + 1",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Real.instIsOrderedRing",
"Int.cast",
"Eq.mpr",
"Real.instLE",
"R... | · refine Or.inl ⟨⌊(j + 1) / r⌋, ?_⟩
rw [beattySeq', sub_eq_iff_eq_add, Int.ceil_eq_iff, Int.cast_add, Int.cast_one]
constructor
· rwa [add_sub_cancel_right]
exact sub_nonneg.1 (Int.sub_floor_div_mul_nonneg (j + 1 : ℝ) h) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.NumberTheory.Zsqrtd.GaussianInt | {
"line": 195,
"column": 12
} | {
"line": 195,
"column": 33
} | [
{
"pp": "x y : ℤ[i]\nthis : |2⁻¹| = 2⁻¹\n⊢ |(↑(toComplex x / toComplex y).re - ↑(toComplex (x / y)).re +\n (↑(toComplex x / toComplex y).im - ↑(toComplex (x / y)).im) * I).im| ≤\n |(1 / 2 + 1 / 2 * I).im|",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"GaussianInt",
"Real.ins... | rw [toComplex_im_div] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.NumberTheory.RatFunc.Ostrowski | {
"line": 218,
"column": 6
} | {
"line": 219,
"column": 35
} | [
{
"pp": "case inr.f\nK : Type u_1\nΓ : Type u_2\ninst✝⁴ : Field K\ninst✝³ : LinearOrderedCommGroupWithZero Γ\nv : Valuation K⟮X⟯ Γ\ninst✝² : v.IsNontrivial\ninst✝¹ : IsTrivialOn K v\nhle : v X ≤ 1\ninst✝ : v.IsRankOneDiscrete\np q : K[X]\nhq0 : q ≠ 0\nhf0 : (algebraMap K[X] K⟮X⟯) p / (algebraMap K[X] K⟮X⟯) q ≠ ... | simp only [map_div₀, valuation_of_algebraMap, intValuation_def, exp_neg, if_neg hp0,
if_neg hq0, div_inv_eq_mul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.NumberTheory.Padics.Hensel | {
"line": 222,
"column": 6
} | {
"line": 227,
"column": 80
} | [] | F.derivative.aeval z * -z1 =
F.derivative.aeval z * -⟨↑(F.aeval z) / ↑(F.derivative.aeval z), h1⟩ := by rw [hzeq]
_ = -(F.derivative.aeval z * ⟨↑(F.aeval z) / ↑(F.derivative.aeval z), h1⟩) := mul_neg _ _
_ = -⟨F.derivative.aeval z * (F.aeval z / (F.derivative.aeval z : ℤ_[p]) : ℚ_[p]), this⟩ :=
... | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcSteps |
Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleNumber | {
"line": 189,
"column": 2
} | {
"line": 189,
"column": 84
} | [
{
"pp": "m : ℕ\nhm : 2 ≤ m\nmZ1 : 1 < ↑m\nm1 : 1 < ↑m\nn p : ℕ\nhp : partialSum (↑m) n = ↑p / ↑m ^ n !\nhpos : 0 < remainder (↑m) n\n⊢ partialSum (↑m) n + remainder (↑m) n ≠ partialSum (↑m) n ∧\n |partialSum (↑m) n + remainder (↑m) n - partialSum (↑m) n| < 1 / (↑m ^ n !) ^ n",
"usedConstants": [
"E... | simpa [abs_of_pos hpos, hpos.ne'] using @remainder_lt n m (by assumption_mod_cast) | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.NumberTheory.Transcendental.Lindemann.AnalyticalPart | {
"line": 178,
"column": 25
} | {
"line": 178,
"column": 39
} | [
{
"pp": "case h.right.refine_1\nf : ℤ[X]\nhf : eval 0 f ≠ 0\nc' : ℂ → ℝ\nc'0 : ∀ (s : ℂ), c' s ≥ 0\nPp'_le : ∀ (s : ℂ) (p : ℕ), p ≠ 0 → ‖P (map (algebraMap ℤ ℂ) (X ^ (p - 1) * f ^ p)) s‖ ≤ c' s ^ p\np : ℕ\np_gt : p > (eval 0 f).natAbs\nprime_p : Nat.Prime p\ngp' : ℤ[X]\nh' : eval 0 (sumIDeriv (X ^ (p - 1) * f ^... | natDegree_pow, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.Transcendental.Liouville.Measure | {
"line": 54,
"column": 2
} | {
"line": 54,
"column": 64
} | [
{
"pp": "p : ℝ\nhp : p > 2\nn : ℕ\nhn : 2 + 1 / (↑n + 1) < p\nx : ℝ\nhxp : LiouvilleWith p x\nhx01 : x ∈ Ico 0 1\nb : ℕ\nhb : 1 ≤ b\na : ℤ\nhlt : |x - ↑a / ↑b| < ↑b ^ (-(2 + 1 / (↑n + 1)))\n⊢ ∃ a ∈ Finset.Icc 0 ↑b, |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(n + 1))",
"usedConstants": [
"Real.instIsOrderedRin... | rw [rpow_neg b.cast_nonneg, ← one_div, ← Nat.cast_succ] at hlt | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleWith | {
"line": 59,
"column": 2
} | {
"line": 61,
"column": 32
} | [
{
"pp": "case h\nx : ℝ\nn : ℕ\nhn : 0 < n\nhn' : 0 < ↑n\n⊢ ∃ m, x ≠ ↑m / ↑n ∧ |x - ↑m / ↑n| < 2 / ↑n ^ 1",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"Real.partialOrder",
"Real",
"Preorder.toLT",
"instHDiv",
"HMul.hMul",
"... | have : x < ↑(⌊x * ↑n⌋ + 1) / ↑n := by
rw [lt_div_iff₀ hn', Int.cast_add, Int.cast_one]
exact Int.lt_floor_add_one _ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleWith | {
"line": 99,
"column": 2
} | {
"line": 108,
"column": 49
} | [
{
"pp": "p q x : ℝ\nh : LiouvilleWith p x\nhlt : q < p\n⊢ ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ |x - ↑m / ↑n| < ↑n ^ (-q)",
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"Iff.mpr",
"sub_pos",
"AddGroup.toSubtractionMonoid",
"NonUnitalNonAssocCommRi... | rcases h.exists_pos with ⟨C, _hC₀, hC⟩
have : ∀ᶠ n : ℕ in atTop, C < n ^ (p - q) := by
simpa only [(· ∘ ·), neg_sub, one_div] using
((tendsto_rpow_atTop (sub_pos.2 hlt)).comp tendsto_natCast_atTop_atTop).eventually
(eventually_gt_atTop C)
refine (this.and_frequently hC).mono ?_
rintro n ⟨hnC, hn... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleWith | {
"line": 99,
"column": 2
} | {
"line": 108,
"column": 49
} | [
{
"pp": "p q x : ℝ\nh : LiouvilleWith p x\nhlt : q < p\n⊢ ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ |x - ↑m / ↑n| < ↑n ^ (-q)",
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"Iff.mpr",
"sub_pos",
"AddGroup.toSubtractionMonoid",
"NonUnitalNonAssocCommRi... | rcases h.exists_pos with ⟨C, _hC₀, hC⟩
have : ∀ᶠ n : ℕ in atTop, C < n ^ (p - q) := by
simpa only [(· ∘ ·), neg_sub, one_div] using
((tendsto_rpow_atTop (sub_pos.2 hlt)).comp tendsto_natCast_atTop_atTop).eventually
(eventually_gt_atTop C)
refine (this.and_frequently hC).mono ?_
rintro n ⟨hnC, hn... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleWith | {
"line": 155,
"column": 82
} | {
"line": 156,
"column": 62
} | [
{
"pp": "p x : ℝ\nn : ℕ\nhn : n ≠ 0\n⊢ LiouvilleWith p (x * ↑n) ↔ LiouvilleWith p x",
"usedConstants": [
"Iff.mpr",
"NormedCommRing.toNormedRing",
"Eq.mpr",
"Real",
"NormedRing.toRing",
"HMul.hMul",
"DivisionRing.toRatCast",
"congrArg",
"Iff.rfl",
... | by
rw [← Rat.cast_natCast, mul_rat_iff (Nat.cast_ne_zero.2 hn)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.NumberTheory.WellApproximable | {
"line": 257,
"column": 6
} | {
"line": 258,
"column": 38
} | [
{
"pp": "T : ℝ\nhT : Fact (0 < T)\nδ : ℕ → ℝ\nhδ : Tendsto δ atTop (𝓝 0)\nthis✝ : SemilatticeSup Nat.Primes := ⋯\nμ : Measure 𝕊 := ⋯\nu : Nat.Primes → 𝕊 := ⋯\nhu₀ : ∀ (p : Nat.Primes), addOrderOf (u p) = ↑p\nhu : Tendsto (addOrderOf ∘ u) atTop atTop\nE : Set 𝕊 := ⋯\nX : ℕ → Set 𝕊 := ⋯\nA : ℕ → Set 𝕊 := ⋯\... | exact blimsup_thickening_mul_ae_eq μ (fun n => 0 < n ∧ p∤n) (fun n => {y | addOrderOf y = n})
(Nat.cast_pos.mpr hp.pos) _ hδ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Probability.Martingale.Basic | {
"line": 77,
"column": 6
} | {
"line": 77,
"column": 77
} | [
{
"pp": "Ω : Type u_1\nE : Type u_2\nι : Type u_3\ninst✝⁴ : Preorder ι\nm0 : MeasurableSpace Ω\ninst✝³ : NormedAddCommGroup E\ninst✝² : NormedSpace ℝ E\ninst✝¹ : OrderBot ι\nℱ : Filtration ι m0\nμ : Measure Ω\ninst✝ : SigmaFiniteFiltration μ ℱ\nf : Ω → E\nhf : StronglyMeasurable f\nhfint : Integrable f μ\ni j :... | condExp_of_stronglyMeasurable (ℱ.le _) (hf.mono <| ℱ.mono bot_le) hfint | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Probability.Martingale.Upcrossing | {
"line": 215,
"column": 2
} | {
"line": 217,
"column": 95
} | [
{
"pp": "Ω : Type u_1\nι : Type u_2\ninst✝ : ConditionallyCompleteLinearOrderBot ι\na b : ℝ\nf : ι → Ω → ℝ\nN : ι\nn m : ℕ\nω : Ω\nhnm : n ≤ m\n⊢ upperCrossingTime a b f N n ω ≤ upperCrossingTime a b f N m ω",
"usedConstants": [
"MeasureTheory.lowerCrossingTime",
"PartialOrder.toPreorder",
... | suffices Monotone fun n => upperCrossingTime a b f N n ω by exact this hnm
exact monotone_nat_of_le_succ fun n =>
le_trans upperCrossingTime_le_lowerCrossingTime lowerCrossingTime_le_upperCrossingTime_succ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Probability.Martingale.Upcrossing | {
"line": 215,
"column": 2
} | {
"line": 217,
"column": 95
} | [
{
"pp": "Ω : Type u_1\nι : Type u_2\ninst✝ : ConditionallyCompleteLinearOrderBot ι\na b : ℝ\nf : ι → Ω → ℝ\nN : ι\nn m : ℕ\nω : Ω\nhnm : n ≤ m\n⊢ upperCrossingTime a b f N n ω ≤ upperCrossingTime a b f N m ω",
"usedConstants": [
"MeasureTheory.lowerCrossingTime",
"PartialOrder.toPreorder",
... | suffices Monotone fun n => upperCrossingTime a b f N n ω by exact this hnm
exact monotone_nat_of_le_succ fun n =>
le_trans upperCrossingTime_le_lowerCrossingTime lowerCrossingTime_le_upperCrossingTime_succ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Probability.Process.HittingTime | {
"line": 166,
"column": 2
} | {
"line": 169,
"column": 8
} | [
{
"pp": "Ω : Type u_1\nβ : Type u_2\nι : Type u_3\ninst✝ : ConditionallyCompleteLinearOrder ι\nu : ι → Ω → β\ns : Set β\nn : ι\nω : Ω\n⊢ ↑n ≤ hittingAfter u s n ω",
"usedConstants": [
"Eq.mpr",
"MeasureTheory.hittingAfter",
"WithTop.coe_le_coe._simp_1",
"WithTop.instPreorder",
... | simp only [hittingAfter]
split_ifs with h
· exact_mod_cast le_csInf h fun b hb => hb.1
· simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Probability.Process.HittingTime | {
"line": 166,
"column": 2
} | {
"line": 169,
"column": 8
} | [
{
"pp": "Ω : Type u_1\nβ : Type u_2\nι : Type u_3\ninst✝ : ConditionallyCompleteLinearOrder ι\nu : ι → Ω → β\ns : Set β\nn : ι\nω : Ω\n⊢ ↑n ≤ hittingAfter u s n ω",
"usedConstants": [
"Eq.mpr",
"MeasureTheory.hittingAfter",
"WithTop.coe_le_coe._simp_1",
"WithTop.instPreorder",
... | simp only [hittingAfter]
split_ifs with h
· exact_mod_cast le_csInf h fun b hb => hb.1
· simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Probability.Martingale.Convergence | {
"line": 202,
"column": 2
} | {
"line": 202,
"column": 36
} | [
{
"pp": "Ω : Type u_1\nm0 : MeasurableSpace Ω\nμ : Measure Ω\nℱ : Filtration ℕ m0\nf : ℕ → Ω → ℝ\nR : ℝ≥0\ninst✝ : IsFiniteMeasure μ\nhf : Submartingale f ℱ μ\nhbdd : ∀ (n : ℕ), eLpNorm (f n) 1 μ ≤ ↑R\nthis : MeasurableSpace Ω := ⨆ n, ↑ℱ n\n⊢ ∀ᵐ (ω : Ω) ∂μ.trim ⋯, ∃ c, Tendsto (fun n ↦ f n ω) atTop (𝓝 c)",
... | rw [ae_iff, trim_measurableSet_eq] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Probability.Martingale.Upcrossing | {
"line": 590,
"column": 4
} | {
"line": 613,
"column": 47
} | [
{
"pp": "Ω : Type u_1\na b : ℝ\nf : ℕ → Ω → ℝ\nN : ℕ\nω : Ω\nhf : a ≤ f N ω\nhab : a < b\nhN : ¬N = 0\nh₁ :\n ∀ (k : ℕ),\n ∑ n ∈ Finset.range N,\n (Set.Ico (lowerCrossingTime a b f N k ω) (upperCrossingTime a b f N (k + 1) ω)).indicator\n (fun m ↦ f (m + 1) ω - f m ω) n =\n stoppedValue... | calc
∑ _k ∈ Finset.range (upcrossingsBefore a b f N ω), (b - a) ≤
∑ k ∈ Finset.range (upcrossingsBefore a b f N ω),
(stoppedValue f (fun ω ↦ (upperCrossingTime a b f N (k + 1) ω : ℕ)) ω -
stoppedValue f (fun ω ↦ (lowerCrossingTime a b f N k ω : ℕ)) ω) := by
gcongr ∑ k ∈... | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcTactic |
Mathlib.Probability.Martingale.Upcrossing | {
"line": 626,
"column": 8
} | {
"line": 626,
"column": 29
} | [
{
"pp": "case refine_2\nΩ : Type u_1\nm0 : MeasurableSpace Ω\nμ : Measure Ω\na b : ℝ\nf : ℕ → Ω → ℝ\nN : ℕ\nℱ : Filtration ℕ m0\ninst✝ : IsFiniteMeasure μ\nhf : Submartingale f ℱ μ\nhfN : ∀ (ω : Ω), a ≤ f N ω\nhfzero : 0 ≤ f 0\nhab : a < b\n⊢ (fun a_1 ↦ (b - a) * ↑(upcrossingsBefore a b f N a_1)) ≤ᶠ[ae μ]\n ... | filter_upwards with ω | Mathlib.Tactic._aux_Mathlib_Order_Filter_Defs___elabRules_Mathlib_Tactic_filterUpwards_1 | Mathlib.Tactic.filterUpwards |
Mathlib.Probability.Martingale.Upcrossing | {
"line": 766,
"column": 4
} | {
"line": 766,
"column": 25
} | [
{
"pp": "Ω : Type u_1\nm0 : MeasurableSpace Ω\nμ : Measure Ω\na b : ℝ\nf : ℕ → Ω → ℝ\nN : ℕ\nℱ : Filtration ℕ m0\ninst✝ : IsFiniteMeasure μ\nhf : StronglyAdapted ℱ f\nhab : a < b\n⊢ ∀ᵐ (ω : Ω) ∂μ, ‖↑(upcrossingsBefore a b f N ω)‖ ≤ ↑N",
"usedConstants": [
"MeasureTheory.ae",
"Norm.norm",
"... | filter_upwards with ω | Mathlib.Tactic._aux_Mathlib_Order_Filter_Defs___elabRules_Mathlib_Tactic_filterUpwards_1 | Mathlib.Tactic.filterUpwards |
Mathlib.Probability.Martingale.Upcrossing | {
"line": 816,
"column": 8
} | {
"line": 819,
"column": 37
} | [
{
"pp": "case pos\nΩ : Type u_1\nm0 : MeasurableSpace Ω\nμ : Measure Ω\nf : ℕ → Ω → ℝ\nℱ : Filtration ℕ m0\ninst✝ : IsFiniteMeasure μ\na b : ℝ\nhf : Submartingale f ℱ μ\nhab : a < b\nthis : ∀ (N : ℕ), ∫⁻ (ω : Ω), ENNReal.ofReal (f N ω - a)⁺ ∂μ = ENNReal.ofReal (∫ (ω : Ω), (f N ω - a)⁺ ∂μ)\nN : ℕ\n⊢ ENNReal.ofRe... | simp_rw [NNReal.coe_natCast]
exact (ENNReal.ofReal_le_ofReal
(hf.mul_integral_upcrossingsBefore_le_integral_pos_part a b N)).trans
(le_iSup (α := ℝ≥0∞) _ N) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Probability.Martingale.Upcrossing | {
"line": 816,
"column": 8
} | {
"line": 819,
"column": 37
} | [
{
"pp": "case pos\nΩ : Type u_1\nm0 : MeasurableSpace Ω\nμ : Measure Ω\nf : ℕ → Ω → ℝ\nℱ : Filtration ℕ m0\ninst✝ : IsFiniteMeasure μ\na b : ℝ\nhf : Submartingale f ℱ μ\nhab : a < b\nthis : ∀ (N : ℕ), ∫⁻ (ω : Ω), ENNReal.ofReal (f N ω - a)⁺ ∂μ = ENNReal.ofReal (∫ (ω : Ω), (f N ω - a)⁺ ∂μ)\nN : ℕ\n⊢ ENNReal.ofRe... | simp_rw [NNReal.coe_natCast]
exact (ENNReal.ofReal_le_ofReal
(hf.mul_integral_upcrossingsBefore_le_integral_pos_part a b N)).trans
(le_iSup (α := ℝ≥0∞) _ N) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Probability.Martingale.Upcrossing | {
"line": 804,
"column": 2
} | {
"line": 825,
"column": 44
} | [
{
"pp": "case pos\nΩ : Type u_1\nm0 : MeasurableSpace Ω\nμ : Measure Ω\nf : ℕ → Ω → ℝ\nℱ : Filtration ℕ m0\ninst✝ : IsFiniteMeasure μ\na b : ℝ\nhf : Submartingale f ℱ μ\nhab : a < b\n⊢ ENNReal.ofReal (b - a) * ∫⁻ (ω : Ω), upcrossings a b f ω ∂μ ≤ ⨆ N, ∫⁻ (ω : Ω), ENNReal.ofReal (f N ω - a)⁺ ∂μ",
"usedConsta... | · simp_rw [upcrossings]
have : ∀ N, ∫⁻ ω, ENNReal.ofReal ((f N ω - a)⁺) ∂μ = ENNReal.ofReal (∫ ω, (f N ω - a)⁺ ∂μ) := by
intro N
rw [ofReal_integral_eq_lintegral_ofReal]
· exact (hf.sub_martingale (martingale_const _ _ _)).pos.integrable _
· exact Eventually.of_forall fun ω => posPart_nonneg... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.