module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.MeasureTheory.VectorMeasure.SetIntegral | {
"line": 423,
"column": 2
} | {
"line": 423,
"column": 71
} | {
"line": 424,
"column": 2
} | [
{
"pp": "case pos\nX : Type u_2\nE : Type u_3\nF : Type u_4\nG : Type u_5\nmX : MeasurableSpace X\ninst✝⁵ : NormedAddCommGroup E\ninst✝⁴ : NormedAddCommGroup F\ninst✝³ : NormedAddCommGroup G\nμ : VectorMeasure X F\nf : X → E\ns : Set X\ninst✝² : NormedSpace ℝ E\ninst✝¹ : NormedSpace ℝ F\ninst✝ : NormedSpace ℝ G... | [
"case pos\nX : Type u_2\nE : Type u_3\nF : Type u_4\nG : Type u_5\nmX : MeasurableSpace X\ninst✝⁵ : NormedAddCommGroup E\ninst✝⁴ : NormedAddCommGroup F\ninst✝³ : NormedAddCommGroup G\nμ : VectorMeasure X F\nf : X → E\ns : Set X\ninst✝² : NormedSpace ℝ E\ninst✝¹ : NormedSpace ℝ F\ninst✝ : NormedSpace ℝ G\nB : E →L[ℝ... | rw [variation_restrict hs, Measure.restrict_apply MeasurableSet.univ] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.ModelTheory.Complexity | {
"line": 360,
"column": 51
} | {
"line": 366,
"column": 77
} | {
"line": 368,
"column": 0
} | [
{
"pp": "L : Language\nα : Type u'\nn : ℕ\nM : Type u_1\ninst✝³ : L.Structure M\nN : Type u_2\ninst✝² : L.Structure N\nF : Type u_3\ninst✝¹ : FunLike F M N\nφ : L.BoundedFormula α n\nhA : φ.IsAtomic\ninst✝ : L.HomClass F M N\nf : F\nhInj : Function.Injective ⇑f\nv : α → M\nxs : Fin n → M\n⊢ φ.Realize v xs → φ.R... | [] | by
induction hA with
| equal t₁ t₂ => simp only [realize_bdEqual, ← Sum.comp_elim, HomClass.realize_term, hInj.eq_iff,
imp_self]
| rel R ts =>
simp only [realize_rel, ← Sum.comp_elim, HomClass.realize_term]
exact HomClass.map_rel f R (fun i => Term.realize (Sum.elim v xs) (ts i)) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.ModelTheory.FinitelyGenerated | {
"line": 126,
"column": 6
} | {
"line": 126,
"column": 12
} | {
"line": 126,
"column": 12
} | [
{
"pp": "L : Language\nM : Type u_1\ninst✝ : L.Structure M\nN : L.Substructure M\n⊢ N.CG ↔ ↑N = ∅ ∨ ∃ s, (closure L).toFun (range s) = N",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"ChainCompletePartialOrder.instOfCompleteLattice",
"FirstOrder.Language.Subst... | [
"L : Language\nM : Type u_1\ninst✝ : L.Structure M\nN : L.Substructure M\n⊢ (∃ S, S.Countable ∧ (closure L).toFun S = N) ↔ ↑N = ∅ ∨ ∃ s, (closure L).toFun (range s) = N"
] | cg_def | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.ModelTheory.FinitelyGenerated | {
"line": 167,
"column": 6
} | {
"line": 167,
"column": 12
} | {
"line": 167,
"column": 12
} | [
{
"pp": "L : Language\nM : Type u_1\ninst✝¹ : L.Structure M\nN : Type u_2\ninst✝ : L.Structure N\nf : M ↪[L] N\ns : L.Substructure M\nt : Set N\nh1 : t.Countable\nh2 : (closure L).toFun t = Substructure.map f.toHom s\n⊢ s.CG",
"ppTerm": "?m.34",
"assigned": true,
"usedConstants": [
"Eq.mpr",
... | [
"L : Language\nM : Type u_1\ninst✝¹ : L.Structure M\nN : Type u_2\ninst✝ : L.Structure N\nf : M ↪[L] N\ns : L.Substructure M\nt : Set N\nh1 : t.Countable\nh2 : (closure L).toFun t = Substructure.map f.toHom s\n⊢ ∃ S, S.Countable ∧ (closure L).toFun S = s"
] | cg_def | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.MeasureTheory.VectorMeasure.Integral | {
"line": 466,
"column": 2
} | {
"line": 466,
"column": 67
} | {
"line": 467,
"column": 2
} | [
{
"pp": "X : Type u_2\nE : Type u_4\nF : Type u_5\nmX : MeasurableSpace X\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedAddCommGroup F\nf : X → E\nμ ν : VectorMeasure X F\nhμ : μ.Integrable f\nhν : ν.Integrable f\n⊢ (μ + ν).Integrable f",
"ppTerm": "?m.131",
"assigned": true,
"usedConstants": [
... | [
"X : Type u_2\nE : Type u_4\nF : Type u_5\nmX : MeasurableSpace X\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedAddCommGroup F\nf : X → E\nμ ν : VectorMeasure X F\nhμ : μ.Integrable f\nhν : ν.Integrable f\n⊢ (μ + ν).variation ≤ μ.variation + ν.variation"
] | apply Integrable.mono_measure (integrable_add_measure.2 ⟨hμ, hν⟩) | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.ModelTheory.PartialEquiv | {
"line": 482,
"column": 2
} | {
"line": 484,
"column": 72
} | {
"line": 485,
"column": 2
} | [
{
"pp": "L : Language\nM : Type w\nN : Type w'\ninst✝¹ : L.Structure M\ninst✝ : L.Structure N\ng : L.FGEquiv M N\nH : L.IsExtensionPair M N\nX : Set M\nleft✝ : X.Countable\nX_gen : (closure L).toFun X = ⊤\nx✝¹ : Countable ↑X\nx✝ : Encodable ↑X\nD : ↑X → Order.Cofinal (L.FGEquiv M N) := fun x ↦ H.definedAtLeft ↑... | [
"L : Language\nM : Type w\nN : Type w'\ninst✝¹ : L.Structure M\ninst✝ : L.Structure N\ng : L.FGEquiv M N\nH : L.IsExtensionPair M N\nX : Set M\nleft✝ : X.Countable\nX_gen : (closure L).toFun X = ⊤\nx✝¹ : Countable ↑X\nx✝ : Encodable ↑X\nD : ↑X → Order.Cofinal (L.FGEquiv M N) := fun x ↦ H.definedAtLeft ↑x\nS : ℕ →o ... | let S : ℕ →o M ≃ₚ[L] N :=
⟨Subtype.val ∘ (Order.sequenceOfCofinals g D),
(Subtype.mono_coe _).comp (Order.sequenceOfCofinals.monotone _ _)⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.ModelTheory.DirectLimit | {
"line": 398,
"column": 2
} | {
"line": 398,
"column": 75
} | {
"line": 400,
"column": 0
} | [
{
"pp": "L : Language\nι : Type v\ninst✝⁷ : Preorder ι\nG : ι → Type w\ninst✝⁶ : (i : ι) → L.Structure (G i)\nf : (i j : ι) → i ≤ j → G i ↪[L] G j\ninst✝⁵ : IsDirectedOrder ι\ninst✝⁴ : DirectedSystem G fun i j h ↦ ⇑(f i j h)\ninst✝³ : Nonempty ι\nP : Type u₁\ninst✝² : L.Structure P\ng✝ : (i : ι) → G i ↪[L] P\nH... | [] | exact ⟨Equiv.ofBijective F ⟨F.injective, surj_f⟩, F.map_fun', F.map_rel'⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.ModelTheory.DirectLimit | {
"line": 414,
"column": 8
} | {
"line": 414,
"column": 19
} | {
"line": 414,
"column": 20
} | [
{
"pp": "case refine_2\nL : Language\nι : Type u_1\ninst✝⁵ : Countable ι\ninst✝⁴ : Preorder ι\ninst✝³ : IsDirectedOrder ι\ninst✝² : Nonempty ι\nG : ι → Type w\ninst✝¹ : (i : ι) → L.Structure (G i)\nf : (i j : ι) → i ≤ j → G i ↪[L] G j\nh : ∀ (i : ι), CG L (G i)\ninst✝ : DirectedSystem G fun i j h ↦ ⇑(f i j h)\n... | [
"case refine_2\nL : Language\nι : Type u_1\ninst✝⁵ : Countable ι\ninst✝⁴ : Preorder ι\ninst✝³ : IsDirectedOrder ι\ninst✝² : Nonempty ι\nG : ι → Type w\ninst✝¹ : (i : ι) → L.Structure (G i)\nf : (i j : ι) → i ≤ j → G i ↪[L] G j\nh : ∀ (i : ι), CG L (G i)\ninst✝ : DirectedSystem G fun i j h ↦ ⇑(f i j h)\n⊢ ⊤ ≤ (Subst... | eq_top_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.ModelTheory.PartialEquiv | {
"line": 511,
"column": 2
} | {
"line": 513,
"column": 72
} | {
"line": 514,
"column": 2
} | [
{
"pp": "L : Language\nM : Type w\nN : Type w'\ninst✝¹ : L.Structure M\ninst✝ : L.Structure N\ng : L.FGEquiv M N\next_dom : L.IsExtensionPair M N\next_cod : L.IsExtensionPair N M\nX : Set M\nX_count : X.Countable\nX_gen : (closure L).toFun X = ⊤\nY : Set N\nY_count : Y.Countable\nY_gen : (closure L).toFun Y = ⊤... | [
"L : Language\nM : Type w\nN : Type w'\ninst✝¹ : L.Structure M\ninst✝ : L.Structure N\ng : L.FGEquiv M N\next_dom : L.IsExtensionPair M N\next_cod : L.IsExtensionPair N M\nX : Set M\nX_count : X.Countable\nX_gen : (closure L).toFun X = ⊤\nY : Set N\nY_count : Y.Countable\nY_gen : (closure L).toFun Y = ⊤\nx✝³ : Coun... | let S : ℕ →o M ≃ₚ[L] N :=
⟨Subtype.val ∘ (Order.sequenceOfCofinals g D),
(Subtype.mono_coe _).comp (Order.sequenceOfCofinals.monotone _ _)⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.ModelTheory.DirectLimit | {
"line": 478,
"column": 2
} | {
"line": 480,
"column": 5
} | {
"line": 482,
"column": 0
} | [
{
"pp": "L : Language\nι : Type v\ninst✝³ : Preorder ι\ninst✝² : Nonempty ι\ninst✝¹ : IsDirectedOrder ι\nM : Type u_1\ninst✝ : L.Structure M\nS : ι →o L.Substructure M\ni : ι\nx : ↥(S i)\n⊢ (Equiv_iSup S).symm ((Substructure.inclusion ⋯) x) =\n (of L ι (fun x ↦ ↥(S x)) (fun x x_1 h ↦ Substructure.inclusion ⋯... | [] | apply (Equiv_iSup S).injective
simp only [Equiv.apply_symm_apply]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.ModelTheory.DirectLimit | {
"line": 478,
"column": 2
} | {
"line": 480,
"column": 5
} | {
"line": 482,
"column": 0
} | [
{
"pp": "L : Language\nι : Type v\ninst✝³ : Preorder ι\ninst✝² : Nonempty ι\ninst✝¹ : IsDirectedOrder ι\nM : Type u_1\ninst✝ : L.Structure M\nS : ι →o L.Substructure M\ni : ι\nx : ↥(S i)\n⊢ (Equiv_iSup S).symm ((Substructure.inclusion ⋯) x) =\n (of L ι (fun x ↦ ↥(S x)) (fun x x_1 h ↦ Substructure.inclusion ⋯... | [] | apply (Equiv_iSup S).injective
simp only [Equiv.apply_symm_apply]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.ModelTheory.Fraisse | {
"line": 394,
"column": 2
} | {
"line": 398,
"column": 3
} | {
"line": 399,
"column": 2
} | [
{
"pp": "L : Language\nK : Set (Bundled L.Structure)\nM : Type w\ninst✝⁴ : L.Structure M\nN : Type w\ninst✝³ : L.Structure N\ninst✝² : Countable ((l : ℕ) × L.Functions l)\ninst✝¹ : Countable M\ninst✝ : Countable N\nhM : IsFraisseLimit K M\nhN : IsFraisseLimit K N\nS : L.Substructure M := ⊥\nS_fg : Structure.FG ... | [
"L : Language\nK : Set (Bundled L.Structure)\nM : Type w\ninst✝⁴ : L.Structure M\nN : Type w\ninst✝³ : L.Structure N\ninst✝² : Countable ((l : ℕ) × L.Functions l)\ninst✝¹ : Countable M\ninst✝ : Countable N\nhM : IsFraisseLimit K M\nhN : IsFraisseLimit K N\nS : L.Substructure M := ⊥\nS_fg : Structure.FG L ↥S\nleft✝ ... | let v : M ≃ₚ[L] N := {
dom := S
cod := emb_S.toHom.range
toEquiv := emb_S.equivRange
} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.ModelTheory.Topology.Types | {
"line": 54,
"column": 21
} | {
"line": 54,
"column": 67
} | {
"line": 56,
"column": 0
} | [
{
"pp": "L : Language\nT : L.Theory\nα : Type u_1\nφ : L[[α]].Sentence\n⊢ IsOpen (T.typesWith φ)ᶜ",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"CompleteType.isOpen_typesWith",
"congrArg",
"Compl.compl",
"FirstOrder.Language.Theory.typesWith",
... | [] | rw [← typesWith_not]; exact isOpen_typesWith _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.ModelTheory.Topology.Types | {
"line": 54,
"column": 21
} | {
"line": 54,
"column": 67
} | {
"line": 56,
"column": 0
} | [
{
"pp": "L : Language\nT : L.Theory\nα : Type u_1\nφ : L[[α]].Sentence\n⊢ IsOpen (T.typesWith φ)ᶜ",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"CompleteType.isOpen_typesWith",
"congrArg",
"Compl.compl",
"FirstOrder.Language.Theory.typesWith",
... | [] | rw [← typesWith_not]; exact isOpen_typesWith _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.ZMod.UnitsCyclic | {
"line": 73,
"column": 2
} | {
"line": 73,
"column": 8
} | {
"line": 75,
"column": 0
} | [
{
"pp": "⊢ φ 4 = 2",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Nat.totient",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"OfNat.ofNat",
"Decidable.decide",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.RingTheory.ZMod.UnitsCyclic | {
"line": 84,
"column": 89
} | {
"line": 84,
"column": 95
} | {
"line": 84,
"column": 95
} | [
{
"pp": "⊢ ∀ (g : (ZMod 8)ˣ), g ^ 2 = 1",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"of_decide_eq_true",
"ZMod.commRing",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"ZMod.fintype",
"ZMod.decidableEq",
"Units",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.RingTheory.ZMod.UnitsCyclic | {
"line": 84,
"column": 89
} | {
"line": 84,
"column": 95
} | {
"line": 84,
"column": 95
} | [
{
"pp": "⊢ ∀ (g : (ZMod 8)ˣ), g ^ 2 = 1",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"of_decide_eq_true",
"ZMod.commRing",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"ZMod.fintype",
"ZMod.decidableEq",
"Units",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.ZMod.UnitsCyclic | {
"line": 84,
"column": 89
} | {
"line": 84,
"column": 95
} | {
"line": 84,
"column": 95
} | [
{
"pp": "⊢ ∀ (g : (ZMod 8)ˣ), g ^ 2 = 1",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"of_decide_eq_true",
"ZMod.commRing",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"ZMod.fintype",
"ZMod.decidableEq",
"Units",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.ArithmeticFunction.Carmichael | {
"line": 135,
"column": 23
} | {
"line": 135,
"column": 29
} | {
"line": 137,
"column": 0
} | [
{
"pp": "case «0»\nn : ℕ\nhn : 0 ≤ 2\n⊢ φ (2 ^ 0) = 2 ^ (0 - 1)",
"ppTerm": "?«0»",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Nat.instMonoid",
"HSub.hSub",
"id",
"instSubNat",
"instOfNatNat",
"Nat.totient",
"NPow.toPow",
"Bool.tr... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.ArithmeticFunction.Carmichael | {
"line": 135,
"column": 23
} | {
"line": 135,
"column": 29
} | {
"line": 137,
"column": 0
} | [
{
"pp": "case «1»\nn : ℕ\nhn : 1 ≤ 2\n⊢ φ (2 ^ 1) = 2 ^ (1 - 1)",
"ppTerm": "?«1»",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Nat.instMonoid",
"HSub.hSub",
"id",
"instSubNat",
"instOfNatNat",
"Nat.totient",
"NPow.toPow",
"Bool.tr... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.ArithmeticFunction.Carmichael | {
"line": 135,
"column": 23
} | {
"line": 135,
"column": 29
} | {
"line": 137,
"column": 0
} | [
{
"pp": "case «2»\nn : ℕ\nhn : 2 ≤ 2\n⊢ φ (2 ^ 2) = 2 ^ (2 - 1)",
"ppTerm": "?«2»",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Nat.instMonoid",
"HSub.hSub",
"id",
"instSubNat",
"instOfNatNat",
"Nat.totient",
"NPow.toPow",
"Bool.tr... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.AbelSummation | {
"line": 99,
"column": 12
} | {
"line": 99,
"column": 93
} | {
"line": 99,
"column": 93
} | [
{
"pp": "𝕜 : Type u_1\ninst✝ : RCLike 𝕜\nc : ℕ → 𝕜\na b : ℝ\nm : ℕ\nha : 0 ≤ a\ng : ℝ → 𝕜\nhg_int : IntegrableOn g (Set.Icc a b) volume\nhab : a ≤ b\nhb : ⌊a⌋₊ = ⌊b⌋₊\nt : ℝ\nht₁ : t ∈ Set.Icc (↑⌊a⌋₊) (↑⌊a⌋₊ + 1) → ∑ k ∈ Icc ?m.134 ⌊t⌋₊, c k = ∑ k ∈ Icc ?m.134 ⌊a⌋₊, c k\nht₂ : t ∈ Set.Icc a b\n⊢ ∑ k ∈ Icc m... | [
"𝕜 : Type u_1\ninst✝ : RCLike 𝕜\nc : ℕ → 𝕜\na b : ℝ\nm : ℕ\nha : 0 ≤ a\ng : ℝ → 𝕜\nhg_int : IntegrableOn g (Set.Icc a b) volume\nhab : a ≤ b\nhb : ⌊a⌋₊ = ⌊b⌋₊\nt : ℝ\nht₁ : t ∈ Set.Icc (↑⌊a⌋₊) (↑⌊a⌋₊ + 1) → ∑ k ∈ Icc m ⌊t⌋₊, c k = ∑ k ∈ Icc m ⌊a⌋₊, c k\nht₂ : t ∈ Set.Icc a b\n⊢ ∑ k ∈ Icc m ⌊a⌋₊, c k = ∑ k ∈ Icc... | ht₁ ⟨(Nat.floor_le ha).trans ht₂.1, hb ▸ ht₂.2.trans (Nat.lt_floor_add_one b).le⟩ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.PowerSeries.Exp | {
"line": 138,
"column": 2
} | {
"line": 138,
"column": 6
} | {
"line": 139,
"column": 2
} | [
{
"pp": "case e_a\nA : Type u_4\ninst✝¹ : CommRing A\ninst✝ : Algebra ℚ A\na b : A\nn x : ℕ\nhx : x ∈ Finset.range n.succ\n⊢ 1 / (↑x ! * ↑(n - x)!) = ↑(n.choose x) / ↑n !",
"ppTerm": "?e_a✝",
"assigned": true,
"usedConstants": [
"Nat.choose",
"instHDiv",
"InvOneClass.toOne",
... | [
"case e_a\nA : Type u_4\ninst✝¹ : CommRing A\ninst✝ : Algebra ℚ A\na b : A\nn x : ℕ\nhx : x ∈ Finset.range n.succ\n⊢ ↑(n.choose x) / ↑n ! = 1 / (↑x ! * ↑(n - x)!)"
] | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.NumberTheory.AbelSummation | {
"line": 146,
"column": 63
} | {
"line": 146,
"column": 76
} | {
"line": 147,
"column": 4
} | [
{
"pp": "case inr\n𝕜 : Type u_1\ninst✝ : RCLike 𝕜\nc : ℕ → 𝕜\nf : ℝ → 𝕜\na b : ℝ\nha : 0 ≤ a\nhab : a ≤ b\nhf_diff : ∀ t ∈ Set.Icc a b, DifferentiableAt ℝ f t\nhf_int : IntegrableOn (deriv f) (Set.Icc a b) volume\naux1 : ↑⌊a⌋₊ ≤ a\naux2 : b ≤ ↑⌊b⌋₊ + 1\nhb : ⌊a⌋₊ < ⌊b⌋₊\naux3 : a ≤ ↑⌊a⌋₊ + 1\naux4 : ↑⌊a⌋₊ +... | [
"case inr\n𝕜 : Type u_1\ninst✝ : RCLike 𝕜\nc : ℕ → 𝕜\nf : ℝ → 𝕜\na b : ℝ\nha : 0 ≤ a\nhab : a ≤ b\nhf_diff : ∀ t ∈ Set.Icc a b, DifferentiableAt ℝ f t\nhf_int : IntegrableOn (deriv f) (Set.Icc a b) volume\naux1 : ↑⌊a⌋₊ ≤ a\naux2 : b ≤ ↑⌊b⌋₊ + 1\nhb : ⌊a⌋₊ < ⌊b⌋₊\naux3 : a ≤ ↑⌊a⌋₊ + 1\naux4 : ↑⌊a⌋₊ + 1 ≤ b\naux5... | range_eq_Ico, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.RingTheory.ZMod.UnitsCyclic | {
"line": 263,
"column": 2
} | {
"line": 263,
"column": 30
} | {
"line": 264,
"column": 2
} | [
{
"pp": "case inr.inl\nhn0 : 1 ≠ 0\n⊢ IsCyclic (ZMod (4 * 1))ˣ ↔ 1 = 0 ∨ 1 = 1",
"ppTerm": "?inr.inl",
"assigned": true,
"usedConstants": [
"False",
"Nat.instMulZeroClass",
"HMul.hMul",
"ZMod.commRing",
"Nat.instOne",
"congrArg",
"CommSemiring.toSemiring",
... | [
"case inr.inr\nn : ℕ\nhn0 : n ≠ 0\nhn1 : n ≠ 1\n⊢ IsCyclic (ZMod (4 * n))ˣ ↔ n = 0 ∨ n = 1"
] | · simp [isCyclic_units_four] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.NumberTheory.BernoulliPolynomials | {
"line": 101,
"column": 42
} | {
"line": 101,
"column": 48
} | {
"line": 101,
"column": 49
} | [
{
"pp": "⊢ 2 ≠ 1",
"ppTerm": "?m.56",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"OfNat.ofNat",
"Decidab... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.BernoulliPolynomials | {
"line": 101,
"column": 42
} | {
"line": 101,
"column": 48
} | {
"line": 101,
"column": 49
} | [
{
"pp": "⊢ 2 ≠ 1",
"ppTerm": "?m.56",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"OfNat.ofNat",
"Decidab... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.BernoulliPolynomials | {
"line": 101,
"column": 42
} | {
"line": 101,
"column": 48
} | {
"line": 101,
"column": 49
} | [
{
"pp": "⊢ 2 ≠ 1",
"ppTerm": "?m.56",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"OfNat.ofNat",
"Decidab... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.BernoulliPolynomials | {
"line": 102,
"column": 42
} | {
"line": 102,
"column": 48
} | {
"line": 102,
"column": 49
} | [
{
"pp": "⊢ 3 ≠ 1",
"ppTerm": "?m.66",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"OfNat.ofNat",
"Decidab... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.BernoulliPolynomials | {
"line": 102,
"column": 42
} | {
"line": 102,
"column": 48
} | {
"line": 102,
"column": 49
} | [
{
"pp": "⊢ 3 ≠ 1",
"ppTerm": "?m.66",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"OfNat.ofNat",
"Decidab... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.BernoulliPolynomials | {
"line": 102,
"column": 42
} | {
"line": 102,
"column": 48
} | {
"line": 102,
"column": 49
} | [
{
"pp": "⊢ 3 ≠ 1",
"ppTerm": "?m.66",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"OfNat.ofNat",
"Decidab... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.BernoulliPolynomials | {
"line": 165,
"column": 4
} | {
"line": 165,
"column": 8
} | {
"line": 166,
"column": 4
} | [
{
"pp": "n p : ℕ\n⊢ ∑ i ∈ range (p + 1), _root_.bernoulli i * ↑((p + 1).choose i) * ↑n ^ (p + 1 - i) =\n ∑ x ∈ range (p.succ + 1), _root_.bernoulli (p.succ - x) * ↑(p.succ.choose x) * ↑n ^ x - _root_.bernoulli p.succ",
"ppTerm": "?m.53",
"assigned": true,
"usedConstants": [
"Rat.instSub",
... | [
"n p : ℕ\n⊢ ∑ x ∈ range (p.succ + 1), _root_.bernoulli (p.succ - x) * ↑(p.succ.choose x) * ↑n ^ x - _root_.bernoulli p.succ =\n ∑ i ∈ range (p + 1), _root_.bernoulli i * ↑((p + 1).choose i) * ↑n ^ (p + 1 - i)"
] | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.RingTheory.ZMod.UnitsCyclic | {
"line": 347,
"column": 6
} | {
"line": 347,
"column": 33
} | {
"line": 348,
"column": 6
} | [
{
"pp": "case neg.inl\nn : ℕ\nh0 : ¬n = 0\nh1 : ¬n = 1\nh2 : ¬n = 2\nh4 : ¬n = 4\nhn : Odd n\n⊢ ¬∃ x x_1, Nat.Prime x ∧ Odd x ∧ 1 ≤ x_1 ∧ n = 2 * x ^ x_1",
"ppTerm": "?neg.inl✝",
"assigned": true,
"usedConstants": [
"False",
"Nat.Prime",
"HMul.hMul",
"Nat.instMonoid",
"... | [
"case neg.inl\np m : ℕ\nh0 : ¬2 * p ^ m = 0\nh1 : ¬2 * p ^ m = 1\nh2 : ¬2 * p ^ m = 2\nh4 : ¬2 * p ^ m = 4\nhn : Odd (2 * p ^ m)\n⊢ False"
] | rintro ⟨p, m, -, -, -, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.NumberTheory.PrimeCounting | {
"line": 140,
"column": 2
} | {
"line": 140,
"column": 8
} | {
"line": 142,
"column": 0
} | [
{
"pp": "⊢ primesBelow 0 = ∅",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Finset",
"id",
"instOfNatNat",
"Finset.decidableEq",
"Finset.instEmptyCollection",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"ins... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.PrimeCounting | {
"line": 140,
"column": 2
} | {
"line": 140,
"column": 8
} | {
"line": 142,
"column": 0
} | [
{
"pp": "⊢ primesBelow 0 = ∅",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Finset",
"id",
"instOfNatNat",
"Finset.decidableEq",
"Finset.instEmptyCollection",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"ins... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.PrimeCounting | {
"line": 140,
"column": 2
} | {
"line": 140,
"column": 8
} | {
"line": 142,
"column": 0
} | [
{
"pp": "⊢ primesBelow 0 = ∅",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Finset",
"id",
"instOfNatNat",
"Finset.decidableEq",
"Finset.instEmptyCollection",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"ins... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.PrimeCounting | {
"line": 144,
"column": 2
} | {
"line": 144,
"column": 8
} | {
"line": 146,
"column": 0
} | [
{
"pp": "⊢ primesBelow 1 = ∅",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Finset",
"id",
"instOfNatNat",
"Finset.decidableEq",
"Finset.instEmptyCollection",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"ins... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.PrimeCounting | {
"line": 144,
"column": 2
} | {
"line": 144,
"column": 8
} | {
"line": 146,
"column": 0
} | [
{
"pp": "⊢ primesBelow 1 = ∅",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Finset",
"id",
"instOfNatNat",
"Finset.decidableEq",
"Finset.instEmptyCollection",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"ins... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.PrimeCounting | {
"line": 144,
"column": 2
} | {
"line": 144,
"column": 8
} | {
"line": 146,
"column": 0
} | [
{
"pp": "⊢ primesBelow 1 = ∅",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Finset",
"id",
"instOfNatNat",
"Finset.decidableEq",
"Finset.instEmptyCollection",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"ins... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.PrimeCounting | {
"line": 148,
"column": 2
} | {
"line": 148,
"column": 8
} | {
"line": 150,
"column": 0
} | [
{
"pp": "⊢ primesBelow 2 = ∅",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Finset",
"id",
"instOfNatNat",
"Finset.decidableEq",
"Finset.instEmptyCollection",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"ins... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.PrimeCounting | {
"line": 148,
"column": 2
} | {
"line": 148,
"column": 8
} | {
"line": 150,
"column": 0
} | [
{
"pp": "⊢ primesBelow 2 = ∅",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Finset",
"id",
"instOfNatNat",
"Finset.decidableEq",
"Finset.instEmptyCollection",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"ins... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.PrimeCounting | {
"line": 148,
"column": 2
} | {
"line": 148,
"column": 8
} | {
"line": 150,
"column": 0
} | [
{
"pp": "⊢ primesBelow 2 = ∅",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Finset",
"id",
"instOfNatNat",
"Finset.decidableEq",
"Finset.instEmptyCollection",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"ins... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.PrimeCounting | {
"line": 269,
"column": 54
} | {
"line": 269,
"column": 67
} | {
"line": 269,
"column": 68
} | [
{
"pp": "a k : ℕ\nh0 : a ≠ 0\nh1 : a < k\nn : ℕ\n⊢ #({x ∈ range (k + n) | Prime x}) ≤ #({p ∈ range k | Prime p}) + #({p ∈ Ico k (k + n) | Prime p})",
"ppTerm": "?m.132",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.Prime",
"congrArg",
"Finset",
"Nat.instLocallyFi... | [
"a k : ℕ\nh0 : a ≠ 0\nh1 : a < k\nn : ℕ\n⊢ #({x ∈ Ico 0 (k + n) | Prime x}) ≤ #({p ∈ range k | Prime p}) + #({p ∈ Ico k (k + n) | Prime p})"
] | range_eq_Ico, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.PrimeCounting | {
"line": 269,
"column": 68
} | {
"line": 269,
"column": 81
} | {
"line": 269,
"column": 82
} | [
{
"pp": "a k : ℕ\nh0 : a ≠ 0\nh1 : a < k\nn : ℕ\n⊢ #({x ∈ Ico 0 (k + n) | Prime x}) ≤ #({p ∈ range k | Prime p}) + #({p ∈ Ico k (k + n) | Prime p})",
"ppTerm": "?m.134",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.Prime",
"congrArg",
"Finset",
"Nat.instLocallyFi... | [
"a k : ℕ\nh0 : a ≠ 0\nh1 : a < k\nn : ℕ\n⊢ #({x ∈ Ico 0 (k + n) | Prime x}) ≤ #({p ∈ Ico 0 k | Prime p}) + #({p ∈ Ico k (k + n) | Prime p})"
] | range_eq_Ico, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.Primorial | {
"line": 50,
"column": 47
} | {
"line": 50,
"column": 53
} | {
"line": 52,
"column": 0
} | [
{
"pp": "⊢ 0# = 1",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"primorial",
"OfNat.ofNat",
"Decidable.decide",
"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.Primorial | {
"line": 50,
"column": 47
} | {
"line": 50,
"column": 53
} | {
"line": 52,
"column": 0
} | [
{
"pp": "⊢ 0# = 1",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"primorial",
"OfNat.ofNat",
"Decidable.decide",
"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Primorial | {
"line": 50,
"column": 47
} | {
"line": 50,
"column": 53
} | {
"line": 52,
"column": 0
} | [
{
"pp": "⊢ 0# = 1",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"primorial",
"OfNat.ofNat",
"Decidable.decide",
"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Primorial | {
"line": 52,
"column": 46
} | {
"line": 52,
"column": 52
} | {
"line": 54,
"column": 0
} | [
{
"pp": "⊢ 1# = 1",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"primorial",
"OfNat.ofNat",
"Decidable.decide",
"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.Primorial | {
"line": 52,
"column": 46
} | {
"line": 52,
"column": 52
} | {
"line": 54,
"column": 0
} | [
{
"pp": "⊢ 1# = 1",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"primorial",
"OfNat.ofNat",
"Decidable.decide",
"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Primorial | {
"line": 52,
"column": 46
} | {
"line": 52,
"column": 52
} | {
"line": 54,
"column": 0
} | [
{
"pp": "⊢ 1# = 1",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"primorial",
"OfNat.ofNat",
"Decidable.decide",
"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Primorial | {
"line": 54,
"column": 46
} | {
"line": 54,
"column": 52
} | {
"line": 56,
"column": 0
} | [
{
"pp": "⊢ 2# = 2",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"primorial",
"OfNat.ofNat",
"Decidable.decide",
"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.Primorial | {
"line": 54,
"column": 46
} | {
"line": 54,
"column": 52
} | {
"line": 56,
"column": 0
} | [
{
"pp": "⊢ 2# = 2",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"primorial",
"OfNat.ofNat",
"Decidable.decide",
"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Primorial | {
"line": 54,
"column": 46
} | {
"line": 54,
"column": 52
} | {
"line": 56,
"column": 0
} | [
{
"pp": "⊢ 2# = 2",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"primorial",
"OfNat.ofNat",
"Decidable.decide",
"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Primorial | {
"line": 75,
"column": 69
} | {
"line": 78,
"column": 94
} | {
"line": 80,
"column": 0
} | [
{
"pp": "m n : ℕ\n⊢ (m + n)# = m# * ∏ p ∈ Ico (m + 1) (m + n + 1) with Nat.Prime p, p",
"ppTerm": "?m.40",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.zero_le",
"Nat.Prime",
"HMul.hMul",
"LinearOrder.toDecidableEq",
"Finset.instUnion",
"Monoid.toMulO... | [] | by
simp_rw [primorial, ← Ico_zero_eq_range]
rw [← prod_union, ← filter_union, Ico_union_Ico_eq_Ico]
exacts [Nat.zero_le _, by lia, disjoint_filter_filter <| Ico_disjoint_Ico_consecutive _ _ _] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.NumberTheory.Primorial | {
"line": 127,
"column": 6
} | {
"line": 127,
"column": 12
} | {
"line": 128,
"column": 4
} | [
{
"pp": "case h.succ.inl.inl\nihn : ∀ m < 0 + 0 + 1, m ≠ 0 → m# < 4 ^ m\nhn : 0 + 0 + 1 ≠ 0\n⊢ (0 + 0 + 1)# < 4 ^ (0 + 0 + 1)",
"ppTerm": "?h.succ.inl.inl",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Nat.instMonoid",
"id",
"instOfNatNat",
"NPow.toPow",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.Primorial | {
"line": 127,
"column": 6
} | {
"line": 127,
"column": 12
} | {
"line": 128,
"column": 4
} | [
{
"pp": "case h.succ.inl.inl\nihn : ∀ m < 0 + 0 + 1, m ≠ 0 → m# < 4 ^ m\nhn : 0 + 0 + 1 ≠ 0\n⊢ (0 + 0 + 1)# < 4 ^ (0 + 0 + 1)",
"ppTerm": "?h.succ.inl.inl",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Nat.instMonoid",
"id",
"instOfNatNat",
"NPow.toPow",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Primorial | {
"line": 127,
"column": 6
} | {
"line": 127,
"column": 12
} | {
"line": 128,
"column": 4
} | [
{
"pp": "case h.succ.inl.inl\nihn : ∀ m < 0 + 0 + 1, m ≠ 0 → m# < 4 ^ m\nhn : 0 + 0 + 1 ≠ 0\n⊢ (0 + 0 + 1)# < 4 ^ (0 + 0 + 1)",
"ppTerm": "?h.succ.inl.inl",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Nat.instMonoid",
"id",
"instOfNatNat",
"NPow.toPow",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Primorial | {
"line": 136,
"column": 6
} | {
"line": 136,
"column": 12
} | {
"line": 137,
"column": 4
} | [
{
"pp": "case h.succ.inr.inl\nihn : ∀ m < 1 + 1, m ≠ 0 → m# < 4 ^ m\nhn : 1 + 1 ≠ 0\nho : Odd 1\n⊢ (1 + 1)# < 4 ^ (1 + 1)",
"ppTerm": "?h.succ.inr.inl",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Nat.instMonoid",
"id",
"instOfNatNat",
"NPow.toPow",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.Primorial | {
"line": 136,
"column": 6
} | {
"line": 136,
"column": 12
} | {
"line": 137,
"column": 4
} | [
{
"pp": "case h.succ.inr.inl\nihn : ∀ m < 1 + 1, m ≠ 0 → m# < 4 ^ m\nhn : 1 + 1 ≠ 0\nho : Odd 1\n⊢ (1 + 1)# < 4 ^ (1 + 1)",
"ppTerm": "?h.succ.inr.inl",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Nat.instMonoid",
"id",
"instOfNatNat",
"NPow.toPow",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Primorial | {
"line": 136,
"column": 6
} | {
"line": 136,
"column": 12
} | {
"line": 137,
"column": 4
} | [
{
"pp": "case h.succ.inr.inl\nihn : ∀ m < 1 + 1, m ≠ 0 → m# < 4 ^ m\nhn : 1 + 1 ≠ 0\nho : Odd 1\n⊢ (1 + 1)# < 4 ^ (1 + 1)",
"ppTerm": "?h.succ.inr.inl",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Nat.instMonoid",
"id",
"instOfNatNat",
"NPow.toPow",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Primorial | {
"line": 144,
"column": 4
} | {
"line": 144,
"column": 10
} | {
"line": 145,
"column": 2
} | [
{
"pp": "case inl\n⊢ 0# ≤ 4 ^ 0",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Nat.instMonoid",
"id",
"instOfNatNat",
"LE.le",
"instLENat",
"NPow.toPow",
"Bool.true",
"HPow.hPow",
"Nat",
"Bool",
"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.Primorial | {
"line": 144,
"column": 4
} | {
"line": 144,
"column": 10
} | {
"line": 145,
"column": 2
} | [
{
"pp": "case inl\n⊢ 0# ≤ 4 ^ 0",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Nat.instMonoid",
"id",
"instOfNatNat",
"LE.le",
"instLENat",
"NPow.toPow",
"Bool.true",
"HPow.hPow",
"Nat",
"Bool",
"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Primorial | {
"line": 144,
"column": 4
} | {
"line": 144,
"column": 10
} | {
"line": 145,
"column": 2
} | [
{
"pp": "case inl\n⊢ 0# ≤ 4 ^ 0",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"Nat.instMonoid",
"id",
"instOfNatNat",
"LE.le",
"instLENat",
"NPow.toPow",
"Bool.true",
"HPow.hPow",
"Nat",
"Bool",
"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Bernoulli | {
"line": 136,
"column": 34
} | {
"line": 136,
"column": 40
} | {
"line": 137,
"column": 2
} | [
{
"pp": "⊢ Nat.choose 4 2 = 6",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Nat.choose",
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"OfNat.ofNat",
"Decidable.de... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.Bernoulli | {
"line": 347,
"column": 8
} | {
"line": 347,
"column": 22
} | {
"line": 347,
"column": 23
} | [
{
"pp": "n p : ℕ\nhne : ∀ (m : ℕ), ↑m ! ≠ 0\nh_cauchy :\n ((PowerSeries.mk fun p ↦ bernoulli p / ↑p !) * PowerSeries.mk fun q ↦ (coeff (q + 1)) (exp ℚ ^ n)) =\n PowerSeries.mk fun p ↦ ∑ i ∈ range (p + 1), bernoulli i * ↑((p + 1).choose i) * ↑n ^ (p + 1 - i) / ↑(p + 1)!\nhexp : exp ℚ - 1 ≠ 0\nh_r : exp ℚ ^ n... | [
"n p : ℕ\nhne : ∀ (m : ℕ), ↑m ! ≠ 0\nh_cauchy :\n ((PowerSeries.mk fun p ↦ bernoulli p / ↑p !) * PowerSeries.mk fun q ↦ (coeff (q + 1)) (exp ℚ ^ n)) =\n PowerSeries.mk fun p ↦ ∑ i ∈ range (p + 1), bernoulli i * ↑((p + 1).choose i) * ↑n ^ (p + 1 - i) / ↑(p + 1)!\nhexp : exp ℚ - 1 ≠ 0\nh_r : exp ℚ ^ n - 1 = X * P... | ← exp_pow_sum, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.ClassNumber.AdmissibleAbsoluteValue | {
"line": 121,
"column": 2
} | {
"line": 121,
"column": 29
} | {
"line": 122,
"column": 2
} | [
{
"pp": "R : Type u_1\ninst✝¹ : EuclideanDomain R\nabv : AbsoluteValue R ℤ\nι : Type u_2\ninst✝ : Fintype ι\nε : ℝ\nhε : 0 < ε\nb : R\nhb : b ≠ 0\nh : abv.IsAdmissible\nA : Fin (h.card ε ^ Fintype.card ι).succ → ι → R\n⊢ ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : ι), ↑(abv (A i₁ k % b - A i₀ k % b)) < abv b • ε",
"ppTerm": ... | [
"R : Type u_1\ninst✝¹ : EuclideanDomain R\nabv : AbsoluteValue R ℤ\nι : Type u_2\ninst✝ : Fintype ι\nε : ℝ\nhε : 0 < ε\nb : R\nhb : b ≠ 0\nh : abv.IsAdmissible\nA : Fin (h.card ε ^ Fintype.card ι).succ → ι → R\ne : ι ≃ Fin (Fintype.card ι) := Fintype.equivFin ι\n⊢ ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : ι), ↑(abv (A i₁ k % b - A... | let e := Fintype.equivFin ι | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.NumberTheory.Bernoulli | {
"line": 501,
"column": 51
} | {
"line": 501,
"column": 57
} | {
"line": 501,
"column": 58
} | [
{
"pp": "inst✝ : Fact (Nat.Prime 2)\nhd : 2 ≥ 2\n⊢ ¬2 ∣ 3",
"ppTerm": "?m.71",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Dvd.dvd",
"of_decide_eq_true",
"Nat.decidable_dvd",
"id",
"instOfNatNat",
"Bool.true",
"Nat.instDvd",
"Nat",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.Bernoulli | {
"line": 501,
"column": 51
} | {
"line": 501,
"column": 57
} | {
"line": 501,
"column": 58
} | [
{
"pp": "inst✝ : Fact (Nat.Prime 2)\nhd : 2 ≥ 2\n⊢ ¬2 ∣ 3",
"ppTerm": "?m.71",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Dvd.dvd",
"of_decide_eq_true",
"Nat.decidable_dvd",
"id",
"instOfNatNat",
"Bool.true",
"Nat.instDvd",
"Nat",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Bernoulli | {
"line": 501,
"column": 51
} | {
"line": 501,
"column": 57
} | {
"line": 501,
"column": 58
} | [
{
"pp": "inst✝ : Fact (Nat.Prime 2)\nhd : 2 ≥ 2\n⊢ ¬2 ∣ 3",
"ppTerm": "?m.71",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Dvd.dvd",
"of_decide_eq_true",
"Nat.decidable_dvd",
"id",
"instOfNatNat",
"Bool.true",
"Nat.instDvd",
"Nat",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Bernoulli | {
"line": 534,
"column": 2
} | {
"line": 534,
"column": 40
} | {
"line": 535,
"column": 2
} | [
{
"pp": "k m p : ℕ\nhm_lt : m < k\ninst✝ : Fact (Nat.Prime p)\nd : ℕ := 2 * k - 2 * m\nhd : d ≥ 2\nhd_def : d = 2 * k - 2 * m\nhd_plus_one_ne_zero : d + 1 ≠ 0\nh_exp : 2 * k - 2 * m - 1 = d - 1\nhkm : 2 * m ≤ 2 * k\nh_denom_rat : 2 * ↑k - 2 * ↑m + 1 = ↑(d + 1)\n⊢ pIntegral p (↑((2 * k).choose (2 * m)) * ↑p ^ (d... | [
"k m p : ℕ\nhm_lt : m < k\ninst✝ : Fact (Nat.Prime p)\nd : ℕ := 2 * k - 2 * m\nhd : d ≥ 2\nhd_def : d = 2 * k - 2 * m\nhd_plus_one_ne_zero : d + 1 ≠ 0\nh_exp : 2 * k - 2 * m - 1 = d - 1\nhkm : 2 * m ≤ 2 * k\nh_denom_rat : 2 * ↑k - 2 * ↑m + 1 = ↑(d + 1)\n⊢ pIntegral p (↑((2 * k).choose (2 * m)) * (↑p ^ (d - 1) / ↑(d... | rw [h_exp, h_denom_rat, mul_div_assoc] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.NumberTheory.Chebyshev | {
"line": 628,
"column": 22
} | {
"line": 628,
"column": 74
} | {
"line": 629,
"column": 2
} | [
{
"pp": "x x✝ : ℝ\n| θ x✝ / (x✝ * log x✝ ^ 2)",
"ppTerm": "?m.56",
"assigned": true,
"usedConstants": [
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"MulOne.toOne",
"Real.partialOrder",
"Real",
"Nat.Prime",
"instHDiv",
"NonUnitalCommRing.toNo... | [
"x x✝ : ℝ\n| 1 / (x✝ * log x✝ ^ 2) * ∑ a ∈ Ioc 0 ⌊x✝⌋₊, if Nat.Prime a then log ↑a else 0"
] | rw [theta, div_eq_mul_one_div, mul_comm, sum_filter] | Lean.Parser.Tactic.Conv._aux_Init_Conv___macroRules_Lean_Parser_Tactic_Conv_convRw___1 | Lean.Parser.Tactic.Conv.convRw__ |
Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter | {
"line": 116,
"column": 2
} | {
"line": 116,
"column": 81
} | {
"line": 117,
"column": 2
} | [
{
"pp": "L : Type u\ninst✝³ : CommRing L\ninst✝² : IsDomain L\ng : L ≃+* L\np : ℕ\ninst✝¹ : Fact (Nat.Prime p)\ninst✝ : ∀ (i : ℕ), HasEnoughRootsOfUnity L (p ^ i)\nk i : ℕ\nhi : k ≤ k + i\nζ : L\nhζ : IsPrimitiveRoot ζ (p ^ (k + i))\nh : IsPrimitiveRoot (ζ ^ p ^ i) (p ^ k)\nh_unit : ⋯.unit = ⋯.unit ^ p ^ i\nH₁ ... | [
"L : Type u\ninst✝³ : CommRing L\ninst✝² : IsDomain L\ng : L ≃+* L\np : ℕ\ninst✝¹ : Fact (Nat.Prime p)\ninst✝ : ∀ (i : ℕ), HasEnoughRootsOfUnity L (p ^ i)\nk i : ℕ\nhi : k ≤ k + i\nζ : L\nhζ : IsPrimitiveRoot ζ (p ^ (k + i))\nh : IsPrimitiveRoot (ζ ^ p ^ i) (p ^ k)\nh_unit : ⋯.unit = ⋯.unit ^ p ^ i\nH₁ : g ζ = ↑(⋯.... | rw [(hζ.isUnit_unit NeZero.out).zpow_eq_one_iff_dvd, mul_comm, ← mul_sub] at H₂ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter | {
"line": 160,
"column": 2
} | {
"line": 160,
"column": 65
} | {
"line": 161,
"column": 2
} | [
{
"pp": "L : Type u\ninst✝² : CommRing L\ninst✝¹ : IsDomain L\nn : ℕ\ninst✝ : NeZero n\n⊢ χ₀ n (RingEquiv.refl L) = 1",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"RingEquiv.refl",
"ZMod.commRing",
"modularCyclotomicCharacter.toFun",
"CommSemiring.toSemiring",
... | [
"L : Type u\ninst✝² : CommRing L\ninst✝¹ : IsDomain L\nn : ℕ\ninst✝ : NeZero n\nt : ↥(rootsOfUnity n L)\n⊢ (RingEquiv.refl L) ↑↑t = ↑(↑t ^ ZMod.val 1)"
] | refine (toFun_unique n (RingEquiv.refl L) 1 <| fun t ↦ ?_).symm | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.RingTheory.Discriminant | {
"line": 193,
"column": 2
} | {
"line": 193,
"column": 41
} | {
"line": 194,
"column": 2
} | [
{
"pp": "case e_a.e_a\nK : Type u\nL : Type v\nE : Type z\ninst✝⁷ : Field K\ninst✝⁶ : Field L\ninst✝⁵ : Field E\ninst✝⁴ : Algebra K L\ninst✝³ : Algebra K E\ninst✝² : Module.Finite K L\ninst✝¹ : IsAlgClosed E\npb : PowerBasis K L\ninst✝ : Algebra.IsSeparable K L\ne : Fin pb.dim ≃ (L →ₐ[K] E)\nthis : ∀ (x : Fin p... | [
"case e_a.e_a\nK : Type u\nL : Type v\nE : Type z\ninst✝⁷ : Field K\ninst✝⁶ : Field L\ninst✝⁵ : Field E\ninst✝⁴ : Algebra K L\ninst✝³ : Algebra K E\ninst✝² : Module.Finite K L\ninst✝¹ : IsAlgClosed E\npb : PowerBasis K L\ninst✝ : Algebra.IsSeparable K L\ne : Fin pb.dim ≃ (L →ₐ[K] E)\nthis : ∀ (x : Fin pb.dim), ↑x +... | have hne : ((2 : ℕ) : ℚ) ≠ 0 := by simp | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.Discriminant | {
"line": 207,
"column": 2
} | {
"line": 210,
"column": 38
} | {
"line": 211,
"column": 2
} | [
{
"pp": "K : Type u\nL : Type v\ninst✝⁴ : Field K\ninst✝³ : Field L\ninst✝² : Algebra K L\ninst✝¹ : Module.Finite K L\npb : PowerBasis K L\ninst✝ : Algebra.IsSeparable K L\nE : Type v := AlgebraicClosure L\nthis : (a b : E) → Decidable (a = b) := fun a b ↦ Classical.propDecidable (a = b)\n⊢ discr K ⇑pb.basis = ... | [
"K : Type u\nL : Type v\ninst✝⁴ : Field K\ninst✝³ : Field L\ninst✝² : Algebra K L\ninst✝¹ : Module.Finite K L\npb : PowerBasis K L\ninst✝ : Algebra.IsSeparable K L\nE : Type v := AlgebraicClosure L\nthis : (a b : E) → Decidable (a = b) := fun a b ↦ Classical.propDecidable (a = b)\ne : Fin pb.dim ≃ (L →ₐ[K] E)\n⊢ di... | have e : Fin pb.dim ≃ (L →ₐ[K] E) := by
refine equivOfCardEq ?_
rw [Fintype.card_fin, AlgHom.card]
exact (PowerBasis.finrank pb).symm | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.Discriminant | {
"line": 211,
"column": 2
} | {
"line": 212,
"column": 74
} | {
"line": 213,
"column": 2
} | [
{
"pp": "K : Type u\nL : Type v\ninst✝⁴ : Field K\ninst✝³ : Field L\ninst✝² : Algebra K L\ninst✝¹ : Module.Finite K L\npb : PowerBasis K L\ninst✝ : Algebra.IsSeparable K L\nE : Type v := AlgebraicClosure L\nthis : (a b : E) → Decidable (a = b) := fun a b ↦ Classical.propDecidable (a = b)\ne : Fin pb.dim ≃ (L →ₐ... | [
"K : Type u\nL : Type v\ninst✝⁴ : Field K\ninst✝³ : Field L\ninst✝² : Algebra K L\ninst✝¹ : Module.Finite K L\npb : PowerBasis K L\ninst✝ : Algebra.IsSeparable K L\nE : Type v := AlgebraicClosure L\nthis : (a b : E) → Decidable (a = b) := fun a b ↦ Classical.propDecidable (a = b)\ne : Fin pb.dim ≃ (L →ₐ[K] E)\nhnod... | have hnodup : ((minpoly K pb.gen).aroots E).Nodup :=
nodup_roots (Separable.map (Algebra.IsSeparable.isSeparable K pb.gen)) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.NumberTheory.Padics.RingHoms | {
"line": 740,
"column": 55
} | {
"line": 740,
"column": 69
} | {
"line": 740,
"column": 69
} | [
{
"pp": "f : ℕ → ℤ\np : ℕ\ninst✝ : Fact (Nat.Prime p)\nhi : ∀ (i : ℕ), ↑p ^ i ∣ f (i + 1) - f i\nε : ℚ\nhε : ε > 0\nk : ℕ\nhk : ↑p ^ (-↑k) < ε\nn : ℕ\nIH : ↑(p ^ k) ∣ f (k + n) - f k\n⊢ ↑p ^ (k + n) = ↑(p ^ k) * ↑p ^ n",
"ppTerm": "?m.119",
"assigned": true,
"usedConstants": [
"NonAssocSemirin... | [] | simp [pow_add] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.NumberTheory.Padics.RingHoms | {
"line": 740,
"column": 55
} | {
"line": 740,
"column": 69
} | {
"line": 740,
"column": 69
} | [
{
"pp": "f : ℕ → ℤ\np : ℕ\ninst✝ : Fact (Nat.Prime p)\nhi : ∀ (i : ℕ), ↑p ^ i ∣ f (i + 1) - f i\nε : ℚ\nhε : ε > 0\nk : ℕ\nhk : ↑p ^ (-↑k) < ε\nn : ℕ\nIH : ↑(p ^ k) ∣ f (k + n) - f k\n⊢ ↑p ^ (k + n) = ↑(p ^ k) * ↑p ^ n",
"ppTerm": "?m.119",
"assigned": true,
"usedConstants": [
"NonAssocSemirin... | [] | simp [pow_add] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Padics.RingHoms | {
"line": 740,
"column": 55
} | {
"line": 740,
"column": 69
} | {
"line": 740,
"column": 69
} | [
{
"pp": "f : ℕ → ℤ\np : ℕ\ninst✝ : Fact (Nat.Prime p)\nhi : ∀ (i : ℕ), ↑p ^ i ∣ f (i + 1) - f i\nε : ℚ\nhε : ε > 0\nk : ℕ\nhk : ↑p ^ (-↑k) < ε\nn : ℕ\nIH : ↑(p ^ k) ∣ f (k + n) - f k\n⊢ ↑p ^ (k + n) = ↑(p ^ k) * ↑p ^ n",
"ppTerm": "?m.119",
"assigned": true,
"usedConstants": [
"NonAssocSemirin... | [] | simp [pow_add] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.PellMatiyasevic | {
"line": 96,
"column": 50
} | {
"line": 96,
"column": 56
} | {
"line": 96,
"column": 56
} | [
{
"pp": "a : ℕ\na1 : 1 < a\n⊢ 0 < 1",
"ppTerm": "?m.46",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"Preorder.toLT",
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat.instPreorder",
"Nat",
"LT.lt",
"Bool",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.PellMatiyasevic | {
"line": 96,
"column": 50
} | {
"line": 96,
"column": 56
} | {
"line": 96,
"column": 56
} | [
{
"pp": "a : ℕ\na1 : 1 < a\n⊢ 0 < 1",
"ppTerm": "?m.46",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"Preorder.toLT",
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat.instPreorder",
"Nat",
"LT.lt",
"Bool",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.PellMatiyasevic | {
"line": 96,
"column": 50
} | {
"line": 96,
"column": 56
} | {
"line": 96,
"column": 56
} | [
{
"pp": "a : ℕ\na1 : 1 < a\n⊢ 0 < 1",
"ppTerm": "?m.46",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"Preorder.toLT",
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat.instPreorder",
"Nat",
"LT.lt",
"Bool",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Dioph | {
"line": 254,
"column": 69
} | {
"line": 254,
"column": 86
} | {
"line": 256,
"column": 0
} | [
{
"pp": "α : Type u\nS S' : Set (α → ℕ)\nd : Dioph S\nH : ∀ (v : α → ℕ), v ∈ S ↔ v ∈ S'\n⊢ Dioph S'",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Set.ext",
"Eq.mpr",
"Dioph",
"congrArg",
"id",
"Nat",
"Eq.symm",
"Eq",
"Set"
],
... | [] | rwa [← Set.ext H] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.NumberTheory.Dioph | {
"line": 254,
"column": 69
} | {
"line": 254,
"column": 86
} | {
"line": 256,
"column": 0
} | [
{
"pp": "α : Type u\nS S' : Set (α → ℕ)\nd : Dioph S\nH : ∀ (v : α → ℕ), v ∈ S ↔ v ∈ S'\n⊢ Dioph S'",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Set.ext",
"Eq.mpr",
"Dioph",
"congrArg",
"id",
"Nat",
"Eq.symm",
"Eq",
"Set"
],
... | [] | rwa [← Set.ext H] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Dioph | {
"line": 254,
"column": 69
} | {
"line": 254,
"column": 86
} | {
"line": 256,
"column": 0
} | [
{
"pp": "α : Type u\nS S' : Set (α → ℕ)\nd : Dioph S\nH : ∀ (v : α → ℕ), v ∈ S ↔ v ∈ S'\n⊢ Dioph S'",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Set.ext",
"Eq.mpr",
"Dioph",
"congrArg",
"id",
"Nat",
"Eq.symm",
"Eq",
"Set"
],
... | [] | rwa [← Set.ext H] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.PellMatiyasevic | {
"line": 437,
"column": 48
} | {
"line": 437,
"column": 54
} | {
"line": 437,
"column": 54
} | [
{
"pp": "a : ℕ\na1 : 1 < a\nn k : ℕ\nhx : xn a1 (n * k) ≡ xn a1 n ^ k [MOD yn a1 n ^ 2]\nhy : yn a1 (n * k) ≡ k * xn a1 n ^ (k - 1) * yn a1 n [MOD yn a1 n ^ 3]\n⊢ 3 ≠ 0",
"ppTerm": "?m.233",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.PellMatiyasevic | {
"line": 437,
"column": 48
} | {
"line": 437,
"column": 54
} | {
"line": 437,
"column": 54
} | [
{
"pp": "a : ℕ\na1 : 1 < a\nn k : ℕ\nhx : xn a1 (n * k) ≡ xn a1 n ^ k [MOD yn a1 n ^ 2]\nhy : yn a1 (n * k) ≡ k * xn a1 n ^ (k - 1) * yn a1 n [MOD yn a1 n ^ 3]\n⊢ 3 ≠ 0",
"ppTerm": "?m.233",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.PellMatiyasevic | {
"line": 437,
"column": 48
} | {
"line": 437,
"column": 54
} | {
"line": 437,
"column": 54
} | [
{
"pp": "a : ℕ\na1 : 1 < a\nn k : ℕ\nhx : xn a1 (n * k) ≡ xn a1 n ^ k [MOD yn a1 n ^ 2]\nhy : yn a1 (n * k) ≡ k * xn a1 n ^ (k - 1) * yn a1 n [MOD yn a1 n ^ 3]\n⊢ 3 ≠ 0",
"ppTerm": "?m.233",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Zsqrtd.Basic | {
"line": 774,
"column": 61
} | {
"line": 774,
"column": 67
} | {
"line": 774,
"column": 67
} | [
{
"pp": "d : ℕ\ndnsq : Nonsquare d\na✝ : ℕ\nxy : { re := -[a✝+1], im := 0 }.Nonneg\nx✝ : (-{ re := -[a✝+1], im := 0 }).Nonneg\n⊢ 0 < 1",
"ppTerm": "?m.62",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.Zsqrtd.Basic | {
"line": 774,
"column": 61
} | {
"line": 774,
"column": 67
} | {
"line": 774,
"column": 67
} | [
{
"pp": "d : ℕ\ndnsq : Nonsquare d\na✝ : ℕ\nxy : { re := -[a✝+1], im := 0 }.Nonneg\nx✝ : (-{ re := -[a✝+1], im := 0 }).Nonneg\n⊢ 0 < 1",
"ppTerm": "?m.62",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Zsqrtd.Basic | {
"line": 774,
"column": 61
} | {
"line": 774,
"column": 67
} | {
"line": 774,
"column": 67
} | [
{
"pp": "d : ℕ\ndnsq : Nonsquare d\na✝ : ℕ\nxy : { re := -[a✝+1], im := 0 }.Nonneg\nx✝ : (-{ re := -[a✝+1], im := 0 }).Nonneg\n⊢ 0 < 1",
"ppTerm": "?m.62",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Zsqrtd.Basic | {
"line": 775,
"column": 68
} | {
"line": 775,
"column": 74
} | {
"line": 775,
"column": 74
} | [
{
"pp": "d : ℕ\ndnsq : Nonsquare d\nn✝ : ℕ\nx✝ : { re := ↑(n✝ + 1), im := 0 }.Nonneg\nyx : (-{ re := ↑(n✝ + 1), im := 0 }).Nonneg\n⊢ 0 < 1",
"ppTerm": "?m.83",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.Zsqrtd.Basic | {
"line": 775,
"column": 68
} | {
"line": 775,
"column": 74
} | {
"line": 775,
"column": 74
} | [
{
"pp": "d : ℕ\ndnsq : Nonsquare d\nn✝ : ℕ\nx✝ : { re := ↑(n✝ + 1), im := 0 }.Nonneg\nyx : (-{ re := ↑(n✝ + 1), im := 0 }).Nonneg\n⊢ 0 < 1",
"ppTerm": "?m.83",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Zsqrtd.Basic | {
"line": 775,
"column": 68
} | {
"line": 775,
"column": 74
} | {
"line": 775,
"column": 74
} | [
{
"pp": "d : ℕ\ndnsq : Nonsquare d\nn✝ : ℕ\nx✝ : { re := ↑(n✝ + 1), im := 0 }.Nonneg\nyx : (-{ re := ↑(n✝ + 1), im := 0 }).Nonneg\n⊢ 0 < 1",
"ppTerm": "?m.83",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.DiophantineApproximation.Basic | {
"line": 257,
"column": 2
} | {
"line": 260,
"column": 63
} | {
"line": 261,
"column": 2
} | [
{
"pp": "ξ : ℚ\nf : ℚ → ℤ × ℕ := fun q ↦ (q.num, q.den)\ns : Set ℚ := {q | |ξ - q| < 1 / ↑q.den ^ 2}\n⊢ s.Finite",
"ppTerm": "?m.90",
"assigned": true,
"usedConstants": [
"Rat.num_div_den",
"Int.cast",
"Eq.mpr",
"Rat.num",
"instHDiv",
"congrArg",
"Rat",
... | [
"ξ : ℚ\nf : ℚ → ℤ × ℕ := fun q ↦ (q.num, q.den)\ns : Set ℚ := {q | |ξ - q| < 1 / ↑q.den ^ 2}\nhinj : Function.Injective f\n⊢ s.Finite"
] | have hinj : Function.Injective f := by
intro a b hab
simp only [f, Prod.mk_inj] at hab
rw [← Rat.num_div_den a, ← Rat.num_div_den b, hab.1, hab.2] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.NumberTheory.PellMatiyasevic | {
"line": 666,
"column": 63
} | {
"line": 666,
"column": 69
} | {
"line": 666,
"column": 69
} | [
{
"pp": "a : ℕ\na1 : 1 < a\ni n : ℕ\nnpos : 0 < n\nj : ℕ\nij : i < j + 1\nj2n : 2 + 1 ≤ 2 * 1\njnn : j + 1 ≠ n\nntriv : ¬(a = 2 ∧ n = 1 ∧ i = 0 ∧ j + 1 = 2)\nlem2 : ∀ k > n, k ≤ 2 * n → ↑(xn a1 k % xn a1 n) = ↑(xn a1 n) - ↑(xn a1 (2 * n - k))\no : j = n ∨ n < j\njn✝ : j > n\njn : j ≠ n\ns : xn a1 j % xn a1 n < ... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.NumberTheory.PellMatiyasevic | {
"line": 666,
"column": 63
} | {
"line": 666,
"column": 69
} | {
"line": 666,
"column": 69
} | [
{
"pp": "a : ℕ\na1 : 1 < a\ni n : ℕ\nnpos : 0 < n\nj : ℕ\nij : i < j + 1\nj2n : 2 + 1 ≤ 2 * 1\njnn : j + 1 ≠ n\nntriv : ¬(a = 2 ∧ n = 1 ∧ i = 0 ∧ j + 1 = 2)\nlem2 : ∀ k > n, k ≤ 2 * n → ↑(xn a1 k % xn a1 n) = ↑(xn a1 n) - ↑(xn a1 (2 * n - k))\no : j = n ∨ n < j\njn✝ : j > n\njn : j ≠ n\ns : xn a1 j % xn a1 n < ... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.PellMatiyasevic | {
"line": 666,
"column": 63
} | {
"line": 666,
"column": 69
} | {
"line": 666,
"column": 69
} | [
{
"pp": "a : ℕ\na1 : 1 < a\ni n : ℕ\nnpos : 0 < n\nj : ℕ\nij : i < j + 1\nj2n : 2 + 1 ≤ 2 * 1\njnn : j + 1 ≠ n\nntriv : ¬(a = 2 ∧ n = 1 ∧ i = 0 ∧ j + 1 = 2)\nlem2 : ∀ k > n, k ≤ 2 * n → ↑(xn a1 k % xn a1 n) = ↑(xn a1 n) - ↑(xn a1 (2 * n - k))\no : j = n ∨ n < j\njn✝ : j > n\njn : j ≠ n\ns : xn a1 j % xn a1 n < ... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.DiophantineApproximation.Basic | {
"line": 413,
"column": 26
} | {
"line": 413,
"column": 34
} | {
"line": 413,
"column": 34
} | [
{
"pp": "ξ : ℝ\nu v : ℤ\nhv : 2 ≤ v\nhcop : IsCoprime u v\nleft✝ : v = 1 → -(1 / 2) < ξ - ↑u\nh : -1 + ξ * (↑v * (2 * ↑v - 1)) < ↑u * (2 * ↑v - 1) ∧ ↑u * (2 * ↑v - 1) < 1 + ξ * (↑v * (2 * ↑v - 1))\nhv₀ : 0 < ↑v\nhv₀' : 0 < 2 * ↑v - 1\nhv₁ : 0 < 2 * v - 1\n⊢ 0 - 1 < (u - ⌊ξ⌋ * v) * (2 * v - 1)",
"ppTerm": "?... | [
"ξ : ℝ\nu v : ℤ\nhv : 2 ≤ v\nhcop : IsCoprime u v\nleft✝ : v = 1 → -(1 / 2) < ξ - ↑u\nh : -1 + ξ * (↑v * (2 * ↑v - 1)) < ↑u * (2 * ↑v - 1) ∧ ↑u * (2 * ↑v - 1) < 1 + ξ * (↑v * (2 * ↑v - 1))\nhv₀ : 0 < ↑v\nhv₀' : 0 < 2 * ↑v - 1\nhv₁ : 0 < 2 * v - 1\n⊢ -1 < (u - ⌊ξ⌋ * v) * (2 * v - 1)"
] | zero_sub | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.PellMatiyasevic | {
"line": 689,
"column": 10
} | {
"line": 689,
"column": 18
} | {
"line": 690,
"column": 8
} | [
{
"pp": "case zero\na : ℕ\na1 : 1 < a\nj n : ℕ\nj2n : j ≤ 2 * n\nnpos : ¬n = 0\njn : j = n\nx0 : 0 < xn a1 0 % xn a1 n\nij : 0 ≤ j\nh : xn a1 0 ≡ xn a1 j [MOD xn a1 n]\nntriv : ¬(a = 2 ∧ n = 1 ∧ 0 = 0 ∧ j = 2)\nij' : 0 < j\n⊢ 0 < xn a1 0 % xn a1 n",
"ppTerm": "?zero",
"assigned": true,
"usedConstant... | [] | exact x0 | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.