module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 365
values | kind stringclasses 368
values |
|---|---|---|---|---|---|---|
Mathlib.Data.Nat.BinaryRec | {
"line": 132,
"column": 47
} | {
"line": 132,
"column": 60
} | [
{
"pp": "b : Bool\nn : Nat\n⊢ b.toNat / 2 + n = n",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"congrArg",
"Bool.toNat",
"id",
"HDiv.hDiv",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Nat.instDiv",
"instAddNat",
"Nat.div_eq_of_... | div_eq_of_lt, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Defs | {
"line": 1268,
"column": 95
} | {
"line": 1269,
"column": 37
} | [
{
"pp": "G : Type u_1\ninst✝ : CommGroup G\na b : G\n⊢ a⁻¹ * (b * a) = b",
"usedConstants": [
"mul_inv_cancel_right",
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"CommMonoid.toCommSemigroup",
"Monoid.toMulOneClass",
"congrArg",
"id",
"MulOne.toMul",
... | by
rw [mul_comm, mul_inv_cancel_right] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.FunLike.Basic | {
"line": 235,
"column": 2
} | {
"line": 235,
"column": 19
} | [
{
"pp": "F : Sort u_1\nα : Sort u_2\nβ : Sort u_3\ni : FunLike F α β\nP : Prop\ninst✝ : Decidable P\nf : P → F\ng : ¬P → F\nx : α\n⊢ (if h : P then f h else g h) x = if h : P then (f h) x else (g h) x",
"usedConstants": [
"Eq.mpr",
"congrArg",
"dif_pos",
"id",
"dif_neg",
... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.FunLike.Basic | {
"line": 235,
"column": 2
} | {
"line": 235,
"column": 19
} | [
{
"pp": "F : Sort u_1\nα : Sort u_2\nβ : Sort u_3\ni : FunLike F α β\nP : Prop\ninst✝ : Decidable P\nf : P → F\ng : ¬P → F\nx : α\n⊢ (if h : P then f h else g h) x = if h : P then (f h) x else (g h) x",
"usedConstants": [
"Eq.mpr",
"congrArg",
"dif_pos",
"id",
"dif_neg",
... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.FunLike.Basic | {
"line": 235,
"column": 2
} | {
"line": 235,
"column": 19
} | [
{
"pp": "F : Sort u_1\nα : Sort u_2\nβ : Sort u_3\ni : FunLike F α β\nP : Prop\ninst✝ : Decidable P\nf : P → F\ng : ¬P → F\nx : α\n⊢ (if h : P then f h else g h) x = if h : P then (f h) x else (g h) x",
"usedConstants": [
"Eq.mpr",
"congrArg",
"dif_pos",
"id",
"dif_neg",
... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Action.Faithful | {
"line": 61,
"column": 37
} | {
"line": 61,
"column": 52
} | [
{
"pp": "M : Type u_1\nG : Type u_2\nα : Type u_3\nR : Type u_4\ninst✝ : MulOneClass R\nr₁ r₂ : R\nh : ∀ (a : R), r₁ • a = r₂ • a\n⊢ r₁ = r₂",
"usedConstants": [
"MulOne.toOne",
"instHSMul",
"instSMulOfMul",
"congrArg",
"Eq.mp",
"MulOne.toMul",
"MulOneClass.toMulOne... | simpa using h 1 | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Group.Action.Faithful | {
"line": 61,
"column": 37
} | {
"line": 61,
"column": 52
} | [
{
"pp": "M : Type u_1\nG : Type u_2\nα : Type u_3\nR : Type u_4\ninst✝ : MulOneClass R\nr₁ r₂ : R\nh : ∀ (a : R), r₁ • a = r₂ • a\n⊢ r₁ = r₂",
"usedConstants": [
"MulOne.toOne",
"instHSMul",
"instSMulOfMul",
"congrArg",
"Eq.mp",
"MulOne.toMul",
"MulOneClass.toMulOne... | simpa using h 1 | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Action.Faithful | {
"line": 61,
"column": 37
} | {
"line": 61,
"column": 52
} | [
{
"pp": "M : Type u_1\nG : Type u_2\nα : Type u_3\nR : Type u_4\ninst✝ : MulOneClass R\nr₁ r₂ : R\nh : ∀ (a : R), r₁ • a = r₂ • a\n⊢ r₁ = r₂",
"usedConstants": [
"MulOne.toOne",
"instHSMul",
"instSMulOfMul",
"congrArg",
"Eq.mp",
"MulOne.toMul",
"MulOneClass.toMulOne... | simpa using h 1 | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Action.Faithful | {
"line": 66,
"column": 37
} | {
"line": 66,
"column": 52
} | [
{
"pp": "M : Type u_1\nG : Type u_2\nα : Type u_3\nR : Type u_4\ninst✝ : MulOneClass R\nr₁ r₂ : Rᵐᵒᵖ\nh : ∀ (a : R), r₁ • a = r₂ • a\n⊢ r₁ = r₂",
"usedConstants": [
"MulOne.toOne",
"instHSMul",
"Mul.toSMulMulOpposite",
"congrArg",
"MulOpposite",
"Eq.mp",
"MulOne.toM... | simpa using h 1 | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Group.Action.Faithful | {
"line": 66,
"column": 37
} | {
"line": 66,
"column": 52
} | [
{
"pp": "M : Type u_1\nG : Type u_2\nα : Type u_3\nR : Type u_4\ninst✝ : MulOneClass R\nr₁ r₂ : Rᵐᵒᵖ\nh : ∀ (a : R), r₁ • a = r₂ • a\n⊢ r₁ = r₂",
"usedConstants": [
"MulOne.toOne",
"instHSMul",
"Mul.toSMulMulOpposite",
"congrArg",
"MulOpposite",
"Eq.mp",
"MulOne.toM... | simpa using h 1 | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Action.Faithful | {
"line": 66,
"column": 37
} | {
"line": 66,
"column": 52
} | [
{
"pp": "M : Type u_1\nG : Type u_2\nα : Type u_3\nR : Type u_4\ninst✝ : MulOneClass R\nr₁ r₂ : Rᵐᵒᵖ\nh : ∀ (a : R), r₁ • a = r₂ • a\n⊢ r₁ = r₂",
"usedConstants": [
"MulOne.toOne",
"instHSMul",
"Mul.toSMulMulOpposite",
"congrArg",
"MulOpposite",
"Eq.mp",
"MulOne.toM... | simpa using h 1 | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Logic.Equiv.Defs | {
"line": 842,
"column": 17
} | {
"line": 842,
"column": 73
} | [
{
"pp": "α : Sort u\nβ : Sort v\nγ : Sort w\nra : α → α → Prop\nrb : β → β → Prop\ne : α ≃ β\neq : ∀ (a₁ a₂ : α), ra a₁ a₂ ↔ rb (e a₁) (e a₂)\n⊢ LeftInverse (Quot.map ⇑e.symm ⋯) (Quot.map ⇑e ⋯)",
"usedConstants": [
"Iff.mpr",
"Equiv.apply_symm_apply",
"Equiv.instEquivLike",
"congrArg... | rintro ⟨a⟩; simp only [Quot.map, Equiv.symm_apply_apply] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Logic.Equiv.Defs | {
"line": 842,
"column": 17
} | {
"line": 842,
"column": 73
} | [
{
"pp": "α : Sort u\nβ : Sort v\nγ : Sort w\nra : α → α → Prop\nrb : β → β → Prop\ne : α ≃ β\neq : ∀ (a₁ a₂ : α), ra a₁ a₂ ↔ rb (e a₁) (e a₂)\n⊢ LeftInverse (Quot.map ⇑e.symm ⋯) (Quot.map ⇑e ⋯)",
"usedConstants": [
"Iff.mpr",
"Equiv.apply_symm_apply",
"Equiv.instEquivLike",
"congrArg... | rintro ⟨a⟩; simp only [Quot.map, Equiv.symm_apply_apply] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Action.Defs | {
"line": 363,
"column": 58
} | {
"line": 363,
"column": 69
} | [
{
"pp": "α : Type u_5\nβ : Type u_6\nγ : Type u_7\nδ : Type u_8\ninst✝⁷ : SMul α β\ninst✝⁶ : SMul α γ\ninst✝⁵ : SMul β δ\ninst✝⁴ : SMul α δ\ninst✝³ : SMul γ δ\ninst✝² : IsScalarTower α β δ\ninst✝¹ : IsScalarTower α γ δ\ninst✝ : SMulCommClass β γ δ\na : α\nb : β\nc : γ\nd : δ\n⊢ (a • b) • c • d = (a • c) • b • d... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Action.Defs | {
"line": 363,
"column": 70
} | {
"line": 363,
"column": 81
} | [
{
"pp": "α : Type u_5\nβ : Type u_6\nγ : Type u_7\nδ : Type u_8\ninst✝⁷ : SMul α β\ninst✝⁶ : SMul α γ\ninst✝⁵ : SMul β δ\ninst✝⁴ : SMul α δ\ninst✝³ : SMul γ δ\ninst✝² : IsScalarTower α β δ\ninst✝¹ : IsScalarTower α γ δ\ninst✝ : SMulCommClass β γ δ\na : α\nb : β\nc : γ\nd : δ\n⊢ a • b • c • d = (a • c) • b • d",... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Action.Defs | {
"line": 519,
"column": 17
} | {
"line": 519,
"column": 28
} | [
{
"pp": "A : Type u_9\nB : Type u_10\nG : Type u_11\ninst✝⁴ : CommMonoid G\ninst✝³ : SMul A G\ninst✝² : SMul B G\ninst✝¹ : IsScalarTower A G G\ninst✝ : IsScalarTower B G G\nr : A\ns : B\nx : G\n⊢ (s • 1) • (r • 1) • x = s • r • 1 • x",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"instHSMu... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Action.Defs | {
"line": 519,
"column": 39
} | {
"line": 519,
"column": 50
} | [
{
"pp": "A : Type u_9\nB : Type u_10\nG : Type u_11\ninst✝⁴ : CommMonoid G\ninst✝³ : SMul A G\ninst✝² : SMul B G\ninst✝¹ : IsScalarTower A G G\ninst✝ : IsScalarTower B G G\nr : A\ns : B\nx : G\n⊢ s • (r • 1) • x = s • r • 1 • x",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"instHSMul",
... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Action.Defs | {
"line": 538,
"column": 6
} | {
"line": 538,
"column": 17
} | [
{
"pp": "α : Type u_5\nM : Type u_9\nN : Type u_10\ninst✝⁴ : Monoid N\ninst✝³ : SMul M N\ninst✝² : MulAction N α\ninst✝¹ : SMul M α\ninst✝ : IsScalarTower M N α\nx : M\ny : α\n⊢ (x • 1) • y = x • y",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"instHSMul",
"smul_assoc",
"Monoi... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Action.Defs | {
"line": 565,
"column": 62
} | {
"line": 565,
"column": 73
} | [
{
"pp": "M : Type u_9\nN : Type u_10\nP : Type u_11\nQ : Type u_12\ninst✝⁹ : SMul M N\ninst✝⁸ : SMul M P\ninst✝⁷ : SMul M Q\ninst✝⁶ : SMul N P\ninst✝⁵ : SMul N Q\ninst✝⁴ : Monoid P\ninst✝³ : MulAction P Q\ninst✝² : IsScalarTower M N P\ninst✝¹ : IsScalarTower M P Q\ninst✝ : IsScalarTower N P Q\nm : M\nn : N\nq :... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Action.Defs | {
"line": 574,
"column": 50
} | {
"line": 574,
"column": 61
} | [
{
"pp": "M : Type u_9\nN : Type u_10\nP : Type u_11\nQ : Type u_12\ninst✝⁹ : SMul M N\ninst✝⁸ : SMul M P\ninst✝⁷ : SMul M Q\ninst✝⁶ : SMul P Q\ninst✝⁵ : Monoid N\ninst✝⁴ : MulAction N P\ninst✝³ : MulAction N Q\ninst✝² : IsScalarTower M N P\ninst✝¹ : IsScalarTower M N Q\ninst✝ : IsScalarTower N P Q\nm : M\np : P... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Tactic.CongrExclamation | {
"line": 570,
"column": 2
} | {
"line": 570,
"column": 13
} | [
{
"pp": "case refl\nα : Sort u_1\nx : α\np : x ≍ x → Prop\nh : ∀ (he : x = x), p ⋯\n⊢ p ⋯",
"usedConstants": [
"rfl"
]
}
] | exact h rfl | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Bool.Basic | {
"line": 193,
"column": 18
} | {
"line": 193,
"column": 42
} | [
{
"pp": "case isFalse\nn m : Nat\nh : n ≤ m\nhn : ¬n = 0\nx✝ : Decidable (m = 0)\n⊢ (!decide (n = 0)) ≤ !decide (m = 0)",
"usedConstants": [
"Decidable.isTrue",
"Decidable.casesOn",
"Bool.not",
"Decidable",
"instOfNatNat",
"LE.le",
"Bool.instLE",
"Nat",
... | cases Nat.decEq m 0 with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | null |
Mathlib.Order.Monotone.Basic | {
"line": 688,
"column": 2
} | {
"line": 689,
"column": 76
} | [
{
"pp": "α : Type u\ninst✝ : Preorder α\nf : ℤ → α\nhf : Monotone f\nn : ℤ\nx : α\nh1 : f n < x\nh2 : x < f (n + 1)\na : ℤ\n⊢ f a ≠ x",
"usedConstants": [
"False",
"Preorder.toLT",
"Int.instLinearOrder",
"PartialOrder.toPreorder",
"Int.le_of_lt_add_one",
"Monotone.reflect... | rintro rfl
exact (hf.reflect_lt h1).not_ge (Int.le_of_lt_add_one <| hf.reflect_lt h2) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Monotone.Basic | {
"line": 688,
"column": 2
} | {
"line": 689,
"column": 76
} | [
{
"pp": "α : Type u\ninst✝ : Preorder α\nf : ℤ → α\nhf : Monotone f\nn : ℤ\nx : α\nh1 : f n < x\nh2 : x < f (n + 1)\na : ℤ\n⊢ f a ≠ x",
"usedConstants": [
"False",
"Preorder.toLT",
"Int.instLinearOrder",
"PartialOrder.toPreorder",
"Int.le_of_lt_add_one",
"Monotone.reflect... | rintro rfl
exact (hf.reflect_lt h1).not_ge (Int.le_of_lt_add_one <| hf.reflect_lt h2) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Heyting.Basic | {
"line": 708,
"column": 57
} | {
"line": 711,
"column": 11
} | [
{
"pp": "α : Type u_2\ninst✝¹ : HeytingAlgebra α\na : α\ninst✝ : Nontrivial α\n⊢ a ≠ aᶜ",
"usedConstants": [
"False",
"Lattice.toSemilatticeSup",
"bot_ne_top._simp_2",
"congrArg",
"HEq.refl",
"Compl.compl",
"False.elim",
"OrderBot.toBot",
"PartialOrder.t... | by
intro h
cases le_compl_self.1 (le_of_eq h)
simp at h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Sigma.Basic | {
"line": 175,
"column": 48
} | {
"line": 175,
"column": 77
} | [
{
"pp": "case h.h.inl.inr\nα : Type u_1\nβ : α → Type u_4\nγ : (a : α) → β a → Type u_7\ninst✝¹ : DecidableEq α\ninst✝ : (a : α) → DecidableEq (β a)\nf : (i : (a : α) × β a) → γ i.fst i.snd\nia : α\nib : β ia\nx : γ ⟨ia, ib⟩.fst ⟨ia, ib⟩.snd\njb : β ia\nhb : ib ≠ jb\n⊢ f ⟨ia, jb⟩ = update (fun y ↦ f ⟨ia, y⟩) ib... | Function.update_of_ne hb.symm | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Logic.Equiv.Sum | {
"line": 271,
"column": 4
} | {
"line": 271,
"column": 21
} | [
{
"pp": "α✝ : Sort u_1\nα₁ : Sort u_2\nα₂ : Sort u_3\nβ : Sort u_4\nβ₁ : Sort u_5\nβ₂ : Sort u_6\nγ : Sort u_7\nδ : Sort u_8\nα : Type u_9\np : α → Prop\ninst✝ : DecidablePred p\na : α\n⊢ Sum.elim Subtype.val Subtype.val (if h : p a then Sum.inl ⟨a, h⟩ else Sum.inr ⟨a, h⟩) = a",
"usedConstants": [
"Eq... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Set.Function | {
"line": 431,
"column": 4
} | {
"line": 436,
"column": 37
} | [
{
"pp": "case refine_2\nα : Type u_1\nβ : Type u_2\ninst✝ : Nonempty β\ns : Set (α × β)\nh : InjOn Prod.fst s\n⊢ ∃ f, s = graphOn f (Prod.fst '' s)",
"usedConstants": [
"_private.Mathlib.Data.Set.Function.0.Set.exists_eq_graphOn_image_fst.match_1_1",
"Iff.mpr",
"Set.image_image",
"Eq... | have : ∀ x ∈ Prod.fst '' s, ∃ y, (x, y) ∈ s := forall_mem_image.2 fun (x, y) h ↦ ⟨y, h⟩
choose! f hf using this
rw [forall_mem_image] at hf
use f
rw [graphOn, image_image, EqOn.image_eq_self]
exact fun x hx ↦ h (hf hx) hx rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Function | {
"line": 431,
"column": 4
} | {
"line": 436,
"column": 37
} | [
{
"pp": "case refine_2\nα : Type u_1\nβ : Type u_2\ninst✝ : Nonempty β\ns : Set (α × β)\nh : InjOn Prod.fst s\n⊢ ∃ f, s = graphOn f (Prod.fst '' s)",
"usedConstants": [
"_private.Mathlib.Data.Set.Function.0.Set.exists_eq_graphOn_image_fst.match_1_1",
"Iff.mpr",
"Set.image_image",
"Eq... | have : ∀ x ∈ Prod.fst '' s, ∃ y, (x, y) ∈ s := forall_mem_image.2 fun (x, y) h ↦ ⟨y, h⟩
choose! f hf using this
rw [forall_mem_image] at hf
use f
rw [graphOn, image_image, EqOn.image_eq_self]
exact fun x hx ↦ h (hf hx) hx rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.Piecewise | {
"line": 156,
"column": 4
} | {
"line": 156,
"column": 50
} | [
{
"pp": "case h.mp\nα : Type u_1\nβ : Type u_2\ns : Set α\ninst✝ : (j : α) → Decidable (j ∈ s)\nf g : α → β\nx : α\n⊢ s.piecewise f g x ∈ f '' s ∪ g '' sᶜ",
"usedConstants": [
"Compl.compl",
"Membership.mem",
"Set.instUnion",
"Set.instCompl",
"dite",
"Set.image",
"U... | by_cases h : x ∈ s <;> [left; right] <;> use x | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.Group.Action.Pi | {
"line": 139,
"column": 2
} | {
"line": 139,
"column": 19
} | [
{
"pp": "case h\nι : Type u_1\nM : Type u_7\nα : Type u_8\nβ : Type u_9\ninst✝ : SMul M β\nr : M\nf : ι → α\ng : ι → β\ne : α → β\nx : α\n⊢ (if h : ∃ a, f a = x then r • g (Classical.choose ⋯) else r • e x) =\n r • if h : ∃ a, f a = x then g (Classical.choose h) else e x",
"usedConstants": [
"Eq.mp... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Set.Prod | {
"line": 681,
"column": 53
} | {
"line": 681,
"column": 82
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝ : Unique ι\nt : (i : ι) → Set (α i)\n⊢ uniqueElim ⁻¹' univ.pi t = t default",
"usedConstants": [
"Set.ext",
"Inhabited.default",
"congrArg",
"Set.mem_univ._simp_1",
"Set.univ",
"instInhabitedTrue",
"Membership.mem",
... | ext; simp [Unique.forall_iff] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Prod | {
"line": 681,
"column": 53
} | {
"line": 681,
"column": 82
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝ : Unique ι\nt : (i : ι) → Set (α i)\n⊢ uniqueElim ⁻¹' univ.pi t = t default",
"usedConstants": [
"Set.ext",
"Inhabited.default",
"congrArg",
"Set.mem_univ._simp_1",
"Set.univ",
"instInhabitedTrue",
"Membership.mem",
... | ext; simp [Unique.forall_iff] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.Function | {
"line": 1248,
"column": 45
} | {
"line": 1248,
"column": 88
} | [
{
"pp": "α₁ : Type u_7\nα₂ : Type u_8\nβ₁ : Type u_9\nβ₂ : Type u_10\ns₁ : Set α₁\ns₂ : Set α₂\nf₁ : α₁ → β₁\nf₂ : α₂ → β₂\nh₁ : InjOn f₁ s₁\nh₂ : InjOn f₂ s₂\nx : α₁ × α₂\nhx : x ∈ s₁ ×ˢ s₂\ny : α₁ × α₂\nhy : y ∈ s₁ ×ˢ s₂\n⊢ f₁ x.1 = f₁ y.1 ∧ f₂ x.2 = f₂ y.2 → x.1 = y.1 ∧ x.2 = y.2",
"usedConstants": [
... | exact And.imp (h₁ hx.1 hy.1) (h₂ hx.2 hy.2) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Set.Prod | {
"line": 1003,
"column": 45
} | {
"line": 1014,
"column": 45
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nf : α → β × γ\nhf₁ : Surjective (Prod.fst ∘ f)\nhf₂ : Surjective (Prod.snd ∘ f)\nhf : ∀ (g₁ g₂ : α), (f g₁).1 = (f g₂).1 ↔ (f g₁).2 = (f g₂).2\n⊢ ∃ e, range f = graphOn (⇑e) univ",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"Set.m... | by
obtain ⟨e₁, he₁⟩ := exists_range_eq_graphOn_univ hf₁ fun _ _ ↦ (hf _ _).1
obtain ⟨e₂, he₂⟩ := exists_range_eq_graphOn_univ (f := Equiv.prodComm _ _ ∘ f) (by simpa) <|
by simp [hf]
have he₁₂ h i : e₁ h = i ↔ e₂ i = h := by
rw [Set.ext_iff] at he₁ he₂
aesop (add simp [Prod.swap_eq_iff_eq_swap])
exa... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Basic | {
"line": 36,
"column": 80
} | {
"line": 36,
"column": 97
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Pow α β\np : Prop\ninst✝ : Decidable p\na : α\nb : p → β\nc : ¬p → β\n⊢ (a ^ if h : p then b h else c h) = if h : p then a ^ b h else a ^ c h",
"usedConstants": [
"Eq.mpr",
"congrArg",
"dif_pos",
"id",
"dif_neg",
"dite",
... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.Group.Basic | {
"line": 36,
"column": 80
} | {
"line": 36,
"column": 97
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Pow α β\np : Prop\ninst✝ : Decidable p\na : α\nb : p → β\nc : ¬p → β\n⊢ (a ^ if h : p then b h else c h) = if h : p then a ^ b h else a ^ c h",
"usedConstants": [
"Eq.mpr",
"congrArg",
"dif_pos",
"id",
"dif_neg",
"dite",
... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Basic | {
"line": 36,
"column": 80
} | {
"line": 36,
"column": 97
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Pow α β\np : Prop\ninst✝ : Decidable p\na : α\nb : p → β\nc : ¬p → β\n⊢ (a ^ if h : p then b h else c h) = if h : p then a ^ b h else a ^ c h",
"usedConstants": [
"Eq.mpr",
"congrArg",
"dif_pos",
"id",
"dif_neg",
"dite",
... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Basic | {
"line": 40,
"column": 80
} | {
"line": 40,
"column": 97
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Pow α β\np : Prop\ninst✝ : Decidable p\na : p → α\nb : ¬p → α\nc : β\n⊢ (if h : p then a h else b h) ^ c = if h : p then a h ^ c else b h ^ c",
"usedConstants": [
"Eq.mpr",
"congrArg",
"dif_pos",
"id",
"dif_neg",
"dite",
... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.Group.Basic | {
"line": 40,
"column": 80
} | {
"line": 40,
"column": 97
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Pow α β\np : Prop\ninst✝ : Decidable p\na : p → α\nb : ¬p → α\nc : β\n⊢ (if h : p then a h else b h) ^ c = if h : p then a h ^ c else b h ^ c",
"usedConstants": [
"Eq.mpr",
"congrArg",
"dif_pos",
"id",
"dif_neg",
"dite",
... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Basic | {
"line": 40,
"column": 80
} | {
"line": 40,
"column": 97
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Pow α β\np : Prop\ninst✝ : Decidable p\na : p → α\nb : ¬p → α\nc : β\n⊢ (if h : p then a h else b h) ^ c = if h : p then a h ^ c else b h ^ c",
"usedConstants": [
"Eq.mpr",
"congrArg",
"dif_pos",
"id",
"dif_neg",
"dite",
... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Basic | {
"line": 1017,
"column": 2
} | {
"line": 1027,
"column": 79
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Monoid β\np r : α → α → Prop\ninst✝ : Std.Total r\nf : α → α → β\nhsymm : Symmetric p\nhf_swap : ∀ {a b : α}, p a b → f a b * f b a = 1\nhmul : ∀ {a b c : α}, r a b → r b c → p a b → p b c → p a c → f a c = f a b * f b c\na b c : α\npab : p a b\npbc : p b c\npac : p... | have hmul' : ∀ {b c}, r b c → p a b → p b c → p a c → f a c = f a b * f b c := by
intro b c rbc pab pbc pac
obtain rab | rba := total_of r a b
· exact hmul rab rbc pab pbc pac
rw [← one_mul (f a c), ← hf_swap pab, mul_assoc]
obtain rac | rca := total_of r a c
· rw [hmul rba rac (hsymm pab) pac p... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Basic | {
"line": 1017,
"column": 2
} | {
"line": 1027,
"column": 79
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Monoid β\np r : α → α → Prop\ninst✝ : Std.Total r\nf : α → α → β\nhsymm : Symmetric p\nhf_swap : ∀ {a b : α}, p a b → f a b * f b a = 1\nhmul : ∀ {a b c : α}, r a b → r b c → p a b → p b c → p a c → f a c = f a b * f b c\na b c : α\npab : p a b\npbc : p b c\npac : p... | have hmul' : ∀ {b c}, r b c → p a b → p b c → p a c → f a c = f a b * f b c := by
intro b c rbc pab pbc pac
obtain rab | rba := total_of r a b
· exact hmul rab rbc pab pbc pac
rw [← one_mul (f a c), ← hf_swap pab, mul_assoc]
obtain rac | rca := total_of r a c
· rw [hmul rba rac (hsymm pab) pac p... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GroupWithZero.Basic | {
"line": 233,
"column": 62
} | {
"line": 233,
"column": 97
} | [
{
"pp": "M₀ : Type u_1\ninst✝ : MonoidWithZero M₀\na : M₀\nn : ℕ\nhn : n ≠ 0\nha : a ^ n ≠ 0\n⊢ a ≠ 0",
"usedConstants": [
"False",
"Ne",
"Monoid.toPow",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"Nat",
"Eq.ndrec",
"Zero.toOfNat0",
"instHPow",
... | rintro rfl; exact ha <| zero_pow hn | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.GroupWithZero.Basic | {
"line": 233,
"column": 62
} | {
"line": 233,
"column": 97
} | [
{
"pp": "M₀ : Type u_1\ninst✝ : MonoidWithZero M₀\na : M₀\nn : ℕ\nhn : n ≠ 0\nha : a ^ n ≠ 0\n⊢ a ≠ 0",
"usedConstants": [
"False",
"Ne",
"Monoid.toPow",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"Nat",
"Eq.ndrec",
"Zero.toOfNat0",
"instHPow",
... | rintro rfl; exact ha <| zero_pow hn | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GroupWithZero.Basic | {
"line": 447,
"column": 2
} | {
"line": 447,
"column": 42
} | [
{
"pp": "G₀ : Type u_2\ninst✝ : GroupWithZero G₀\na : G₀\nh : a ≠ 0\n⊢ 1 / a ≠ 0",
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"DivInvMonoid.toInv",
"instHDiv",
"GroupWithZero.toDivisionMonoid",
"InvOneClass.toOne",
"GroupWithZero.toDivInvMonoid",... | simpa only [one_div] using inv_ne_zero h | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.GroupWithZero.Basic | {
"line": 447,
"column": 2
} | {
"line": 447,
"column": 42
} | [
{
"pp": "G₀ : Type u_2\ninst✝ : GroupWithZero G₀\na : G₀\nh : a ≠ 0\n⊢ 1 / a ≠ 0",
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"DivInvMonoid.toInv",
"instHDiv",
"GroupWithZero.toDivisionMonoid",
"InvOneClass.toOne",
"GroupWithZero.toDivInvMonoid",... | simpa only [one_div] using inv_ne_zero h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.GroupWithZero.Basic | {
"line": 447,
"column": 2
} | {
"line": 447,
"column": 42
} | [
{
"pp": "G₀ : Type u_2\ninst✝ : GroupWithZero G₀\na : G₀\nh : a ≠ 0\n⊢ 1 / a ≠ 0",
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"DivInvMonoid.toInv",
"instHDiv",
"GroupWithZero.toDivisionMonoid",
"InvOneClass.toOne",
"GroupWithZero.toDivInvMonoid",... | simpa only [one_div] using inv_ne_zero h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Cast.Defs | {
"line": 95,
"column": 2
} | {
"line": 95,
"column": 19
} | [
{
"pp": "R : Type u_1\ninst✝¹ : AddMonoidWithOne R\nP : Prop\ninst✝ : Decidable P\nm n : ℕ\n⊢ ↑(if P then m else n) = if P then ↑m else ↑n",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"AddMonoidWithOne.toNatCast",
"if_pos",
"Nat.cast",
"dite",
"Nat",
... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Nat.Cast.Defs | {
"line": 95,
"column": 2
} | {
"line": 95,
"column": 19
} | [
{
"pp": "R : Type u_1\ninst✝¹ : AddMonoidWithOne R\nP : Prop\ninst✝ : Decidable P\nm n : ℕ\n⊢ ↑(if P then m else n) = if P then ↑m else ↑n",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"AddMonoidWithOne.toNatCast",
"if_pos",
"Nat.cast",
"dite",
"Nat",
... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Cast.Defs | {
"line": 95,
"column": 2
} | {
"line": 95,
"column": 19
} | [
{
"pp": "R : Type u_1\ninst✝¹ : AddMonoidWithOne R\nP : Prop\ninst✝ : Decidable P\nm n : ℕ\n⊢ ↑(if P then m else n) = if P then ↑m else ↑n",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"AddMonoidWithOne.toNatCast",
"if_pos",
"Nat.cast",
"dite",
"Nat",
... | split_ifs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GroupWithZero.Action.Defs | {
"line": 244,
"column": 61
} | {
"line": 244,
"column": 76
} | [
{
"pp": "M : Type u_1\nM₀ : Type u_2\nM₀' : Type u_3\nG₀ : Type u_4\nG₀' : Type u_5\nN : Type u_6\nA : Type u_7\nA' : Type u_8\nB : Type u_9\nα : Type u_10\nβ : Type u_11\ninst✝⁶ : MonoidWithZero M₀\ninst✝⁵ : MonoidWithZero M₀'\ninst✝⁴ : Zero A\ninst✝³ : MulActionWithZero M₀ A\ninst✝² : Zero A'\ninst✝¹ : SMul M... | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Ring.Defs | {
"line": 160,
"column": 6
} | {
"line": 160,
"column": 14
} | [
{
"pp": "α : Type u\ninst✝² : Add α\ninst✝¹ : MulOneClass α\ninst✝ : LeftDistribClass α\na b : α\n⊢ a * (b + 1) = a * b + a",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
"congrArg",
"id",
"MulOne.toMul",
"instHAdd",
"MulOneClass.toMulOne",
... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Defs | {
"line": 166,
"column": 6
} | {
"line": 166,
"column": 14
} | [
{
"pp": "α : Type u\ninst✝² : Add α\ninst✝¹ : MulOneClass α\ninst✝ : LeftDistribClass α\na b : α\n⊢ a * (1 + b) = a + a * b",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
"congrArg",
"id",
"MulOne.toMul",
"instHAdd",
"MulOneClass.toMulOne",
... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Defs | {
"line": 183,
"column": 37
} | {
"line": 183,
"column": 51
} | [
{
"pp": "case succ\nα : Type u\ninst✝ : NonAssocSemiring α\na : α\nn : ℕ\nih : n • a = ↑n * a\n⊢ ↑n * a + a = ↑(n + 1) * a",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.cast_succ",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"congrArg",
... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Defs | {
"line": 320,
"column": 52
} | {
"line": 320,
"column": 61
} | [
{
"pp": "α : Type u\nR : Type v\ninst✝¹ : MulZeroClass α\ninst✝ : HasDistribNeg α\n⊢ -0 * 0 = 0 * 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"id",
"MulZeroClass.mul_zero",
"Zero.toOfNat0",
"HasDistribNeg.toInvolutiveNeg",
... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Int.Cast.Basic | {
"line": 109,
"column": 6
} | {
"line": 109,
"column": 20
} | [
{
"pp": "R : Type u\ninst✝ : AddGroupWithOne R\nm n : ℕ\n⊢ -↑(m + n + 1 + 1) = -↑(m + 1) + -↑(n + 1)",
"usedConstants": [
"neg_add_rev",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"AddMonoid.toAddSemigroup",
"AddGroupWithOne.toAddGroup",
"congrA... | ← neg_add_rev, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Int.Even | {
"line": 88,
"column": 2
} | {
"line": 95,
"column": 22
} | [
{
"pp": "z : ℤ\n⊢ IsSquare z.sign ↔ 0 ≤ z",
"usedConstants": [
"Int.instAddCommGroup",
"Eq.mpr",
"NegZeroClass.toNeg",
"False",
"Int.ctorIdx",
"_private.Mathlib.Algebra.Group.Int.Even.0.Int.isSquare_sign_iff._simp_1_2",
"HMul.hMul",
"Int.induction_on",
"... | induction z using Int.induction_on with
| zero => simpa using ⟨0, by simp⟩
| succ => norm_cast; simp
| pred =>
rw [sign_eq_neg_one_of_neg (by lia), ← neg_add', Int.neg_nonneg]
norm_cast
simp only [reduceNeg, le_zero_eq, Nat.add_eq_zero_iff, succ_ne_self, and_false, iff_false]
rintro ⟨a | a, ⟨⟩⟩ | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Algebra.Group.Int.Even | {
"line": 88,
"column": 2
} | {
"line": 95,
"column": 22
} | [
{
"pp": "z : ℤ\n⊢ IsSquare z.sign ↔ 0 ≤ z",
"usedConstants": [
"Int.instAddCommGroup",
"Eq.mpr",
"NegZeroClass.toNeg",
"False",
"Int.ctorIdx",
"_private.Mathlib.Algebra.Group.Int.Even.0.Int.isSquare_sign_iff._simp_1_2",
"HMul.hMul",
"Int.induction_on",
"... | induction z using Int.induction_on with
| zero => simpa using ⟨0, by simp⟩
| succ => norm_cast; simp
| pred =>
rw [sign_eq_neg_one_of_neg (by lia), ← neg_add', Int.neg_nonneg]
norm_cast
simp only [reduceNeg, le_zero_eq, Nat.add_eq_zero_iff, succ_ne_self, and_false, iff_false]
rintro ⟨a | a, ⟨⟩⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Int.Even | {
"line": 88,
"column": 2
} | {
"line": 95,
"column": 22
} | [
{
"pp": "z : ℤ\n⊢ IsSquare z.sign ↔ 0 ≤ z",
"usedConstants": [
"Int.instAddCommGroup",
"Eq.mpr",
"NegZeroClass.toNeg",
"False",
"Int.ctorIdx",
"_private.Mathlib.Algebra.Group.Int.Even.0.Int.isSquare_sign_iff._simp_1_2",
"HMul.hMul",
"Int.induction_on",
"... | induction z using Int.induction_on with
| zero => simpa using ⟨0, by simp⟩
| succ => norm_cast; simp
| pred =>
rw [sign_eq_neg_one_of_neg (by lia), ← neg_add', Int.neg_nonneg]
norm_cast
simp only [reduceNeg, le_zero_eq, Nat.add_eq_zero_iff, succ_ne_self, and_false, iff_false]
rintro ⟨a | a, ⟨⟩⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Cast.Basic | {
"line": 69,
"column": 37
} | {
"line": 69,
"column": 51
} | [
{
"pp": "case succ\nα : Type u_1\ninst✝ : NonAssocSemiring α\na : α\nn : ℕ\nih : n • a = a * ↑n\n⊢ a * ↑n + a = a * ↑(n + 1)",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.cast_succ",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"congrArg",
... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Cast.Basic | {
"line": 69,
"column": 52
} | {
"line": 69,
"column": 60
} | [
{
"pp": "case succ\nα : Type u_1\ninst✝ : NonAssocSemiring α\na : α\nn : ℕ\nih : n • a = a * ↑n\n⊢ a * ↑n + a = a * (↑n + 1)",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"con... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Hom.Defs | {
"line": 613,
"column": 10
} | {
"line": 613,
"column": 18
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\ninst✝² : CommRing α\ninst✝¹ : IsDomain α\ninst✝ : CommRing β\nf : β →+ α\nh : ∀ (x : β), f (x * x) = f x * f x\nh_two : 2 ≠ 0\nh_one : f 1 = 1\nx y : β\nhxy : f ((x + y) * (x + y)) = f (x + y) * f (x + y)\n⊢ (↑f).toFun (x * y) = (↑f).toFun x * (↑f... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Hom.Defs | {
"line": 614,
"column": 8
} | {
"line": 614,
"column": 16
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\ninst✝² : CommRing α\ninst✝¹ : IsDomain α\ninst✝ : CommRing β\nf : β →+ α\nh : ∀ (x : β), f (x * x) = f x * f x\nh_two : 2 ≠ 0\nh_one : f 1 = 1\nx y : β\nhxy : f x * f x + f (y * x) + (f (x * y) + f y * f y) = f x * (f x + f y) + f y * (f x + f y)\... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Hom.Defs | {
"line": 614,
"column": 17
} | {
"line": 614,
"column": 25
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\ninst✝² : CommRing α\ninst✝¹ : IsDomain α\ninst✝ : CommRing β\nf : β →+ α\nh : ∀ (x : β), f (x * x) = f x * f x\nh_two : 2 ≠ 0\nh_one : f 1 = 1\nx y : β\nhxy : f x * f x + f (y * x) + (f (x * y) + f y * f y) = f x * f x + f x * f y + f y * (f x + f... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Units | {
"line": 125,
"column": 6
} | {
"line": 125,
"column": 14
} | [
{
"pp": "R : Type x\ninst✝ : Semiring R\na : Rˣ\nb : R\n⊢ ↑a + b = ↑a * (1 + ↑a⁻¹ * b)",
"usedConstants": [
"Distrib.leftDistribClass",
"Units.val",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"congrArg",
"Units",
"id",
"Distrib.toA... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Commute | {
"line": 53,
"column": 6
} | {
"line": 53,
"column": 14
} | [
{
"pp": "R : Type u\ninst✝ : NonUnitalNonAssocRing R\na b : R\nh : Commute a b\n⊢ a * a - b * b = (a - b) * (a + b)",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"HMul.hMul",
"congrArg",
"NonUnitalNonAssocRing.toAddCommGroup",
"HSub.hSub",
"AddCommGroup... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Cast.Commute | {
"line": 27,
"column": 2
} | {
"line": 29,
"column": 77
} | [
{
"pp": "α : Type u_1\ninst✝ : NonAssocSemiring α\nn : ℕ\nx : α\n⊢ Commute (↑n) x",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.cast_succ",
"Nat.recAux",
"AddMonoid.toAddSemigroup",
"congrArg",
"Commute.zero_left",
"AddMonoid.t... | induction n with
| zero => rw [Nat.cast_zero]; exact Commute.zero_left x
| succ n ihn => rw [Nat.cast_succ]; exact ihn.add_left (Commute.one_left x) | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Nat.Cast.Commute | {
"line": 27,
"column": 2
} | {
"line": 29,
"column": 77
} | [
{
"pp": "α : Type u_1\ninst✝ : NonAssocSemiring α\nn : ℕ\nx : α\n⊢ Commute (↑n) x",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.cast_succ",
"Nat.recAux",
"AddMonoid.toAddSemigroup",
"congrArg",
"Commute.zero_left",
"AddMonoid.t... | induction n with
| zero => rw [Nat.cast_zero]; exact Commute.zero_left x
| succ n ihn => rw [Nat.cast_succ]; exact ihn.add_left (Commute.one_left x) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Cast.Commute | {
"line": 27,
"column": 2
} | {
"line": 29,
"column": 77
} | [
{
"pp": "α : Type u_1\ninst✝ : NonAssocSemiring α\nn : ℕ\nx : α\n⊢ Commute (↑n) x",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.cast_succ",
"Nat.recAux",
"AddMonoid.toAddSemigroup",
"congrArg",
"Commute.zero_left",
"AddMonoid.t... | induction n with
| zero => rw [Nat.cast_zero]; exact Commute.zero_left x
| succ n ihn => rw [Nat.cast_succ]; exact ihn.add_left (Commute.one_left x) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Ring.InjSurj | {
"line": 77,
"column": 49
} | {
"line": 77,
"column": 63
} | [
{
"pp": "R : Type u_1\nS : Type u_2\nf✝ : S → R\nhf✝ : Injective f✝\ninst✝¹¹ : Add S\ninst✝¹⁰ : Mul S\ninst✝⁹ : Zero S\ninst✝⁸ : One S\ninst✝⁷ : Neg S\ninst✝⁶ : Sub S\ninst✝⁵ : SMul ℕ S\ninst✝⁴ : SMul ℤ S\ninst✝³ : Pow S ℕ\ninst✝² : NatCast S\ninst✝¹ : IntCast S\ninst✝ : AddMonoidWithOne R\nf : S → R\nhf : Inje... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.InjSurj | {
"line": 101,
"column": 50
} | {
"line": 101,
"column": 58
} | [
{
"pp": "R : Type u_1\nS✝ : Type u_2\nf✝ : S✝ → R\nhf✝ : Injective f✝\ninst✝²⁰ : Add S✝\ninst✝¹⁹ : Mul S✝\ninst✝¹⁸ : Zero S✝\ninst✝¹⁷ : One S✝\ninst✝¹⁶ : Neg S✝\ninst✝¹⁵ : Sub S✝\ninst✝¹⁴ : SMul ℕ S✝\ninst✝¹³ : SMul ℤ S✝\ninst✝¹² : Pow S✝ ℕ\ninst✝¹¹ : NatCast S✝\ninst✝¹⁰ : IntCast S✝\nS : Type ?u.5267\ninst✝⁹ :... | intCast, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.InjSurj | {
"line": 102,
"column": 43
} | {
"line": 102,
"column": 51
} | [
{
"pp": "R : Type u_1\nS✝ : Type u_2\nf✝ : S✝ → R\nhf✝ : Injective f✝\ninst✝²⁰ : Add S✝\ninst✝¹⁹ : Mul S✝\ninst✝¹⁸ : Zero S✝\ninst✝¹⁷ : One S✝\ninst✝¹⁶ : Neg S✝\ninst✝¹⁵ : Sub S✝\ninst✝¹⁴ : SMul ℕ S✝\ninst✝¹³ : SMul ℤ S✝\ninst✝¹² : Pow S✝ ℕ\ninst✝¹¹ : NatCast S✝\ninst✝¹⁰ : IntCast S✝\nS : Type ?u.5267\ninst✝⁹ :... | intCast, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Module.NatInt | {
"line": 118,
"column": 21
} | {
"line": 118,
"column": 35
} | [
{
"pp": "case succ\nR : Type u_1\nM : Type u_3\ninst✝² : Semiring R\ninst✝¹ : AddCommMonoid M\ninst✝ : Module R M\nb : M\nn : ℕ\nih : ↑n • b = n • b\n⊢ ↑(n + 1) • b = (n + 1) • b",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.cast_succ",
"instHSMul",
... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.InjSurj | {
"line": 326,
"column": 47
} | {
"line": 326,
"column": 61
} | [
{
"pp": "R : Type u_1\nS : Type u_2\nf : R → S\nhf : Surjective f\ninst✝¹¹ : Add S\ninst✝¹⁰ : Mul S\ninst✝⁹ : Zero S\ninst✝⁸ : One S\ninst✝⁷ : Neg S\ninst✝⁶ : Sub S\ninst✝⁵ : SMul ℕ S\ninst✝⁴ : SMul ℤ S\ninst✝³ : Pow S ℕ\ninst✝² : NatCast S\ninst✝¹ : IntCast S\ninst✝ : AddMonoidWithOne R\nzero : f 0 = 0\none : ... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Parity | {
"line": 111,
"column": 49
} | {
"line": 111,
"column": 57
} | [
{
"pp": "α : Type u_2\ninst✝ : Semiring α\na b : α\n⊢ a + a + (2 * b + 1) = 2 * (a + b) + 1",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"congrArg",
"id",
"Distrib.toAdd",
"AddMonoidWithOne.... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Parity | {
"line": 145,
"column": 6
} | {
"line": 145,
"column": 14
} | [
{
"pp": "α : Type u_2\ninst✝ : Semiring α\na b : α\n⊢ (2 * a + 1) * (2 * b + 1) = 2 * (2 * a * b + b + a) + 1",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"congrArg",
"Nat.instAtLeastTwoHAddOfNat",
... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Parity | {
"line": 205,
"column": 15
} | {
"line": 205,
"column": 23
} | [
{
"pp": "case h\nα : Type u_2\ninst✝ : Ring α\na k : α\nhk : a = 2 * k + 1\n⊢ -a = -(2 * (k + 1)) + 1",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"Ring.toNonAssocRing",
"con... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Parity | {
"line": 373,
"column": 2
} | {
"line": 373,
"column": 36
} | [
{
"pp": "α : Type u_4\nf : α → α\nhf : Involutive f\nm : ℕ\n⊢ f^[m + m] = id",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"congrArg",
"Nat.instAtLeastTwoHAddOfNat",
"two_mul",
"id",
"Distrib.toAdd",
"AddMonoidWit... | rw [← two_mul, hf.iterate_two_mul] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Group.Unbundled.Basic | {
"line": 158,
"column": 51
} | {
"line": 159,
"column": 62
} | [
{
"pp": "α : Type u\ninst✝² : Group α\ninst✝¹ : LE α\ninst✝ : MulRightMono α\na b : α\n⊢ 1 ≤ a * b⁻¹ ↔ b ≤ a",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"DivInvMonoid.toInv",
"InvOneClass.toOne",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass... | by
rw [← mul_le_mul_iff_right b, one_mul, inv_mul_cancel_right] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.RelIso.Basic | {
"line": 167,
"column": 4
} | {
"line": 167,
"column": 32
} | [
{
"pp": "case inl\nα : Type u_1\nβ : Type u_2\nr : α → α → Prop\ns : β → β → Prop\ninst✝¹ : Std.Trichotomous r\ninst✝ : Std.Irrefl s\nf : α → β\nhf : ∀ {x y : α}, r x y → s (f x) (f y)\nx y : α\nhxy : f x = f y\nh : r x y\nthis : s (f y) (f y)\n⊢ False",
"usedConstants": [
"irrefl_of"
]
}
] | exact irrefl_of s (f y) this | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.RelIso.Basic | {
"line": 172,
"column": 4
} | {
"line": 172,
"column": 32
} | [
{
"pp": "case inr.inr\nα : Type u_1\nβ : Type u_2\nr : α → α → Prop\ns : β → β → Prop\ninst✝¹ : Std.Trichotomous r\ninst✝ : Std.Irrefl s\nf : α → β\nhf : ∀ {x y : α}, r x y → s (f x) (f y)\nx y : α\nhxy : f x = f y\nh : r y x\nthis : s (f y) (f y)\n⊢ False",
"usedConstants": [
"irrefl_of"
]
}
] | exact irrefl_of s (f y) this | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.RelIso.Basic | {
"line": 727,
"column": 16
} | {
"line": 727,
"column": 32
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nδ : Type u_4\nr : α → α → Prop\ns : β → β → Prop\nt : γ → γ → Prop\nu : δ → δ → Prop\ne : r ≃r s\nf : α → β\ng : β → α\nhf : f = ⇑e\nhg : g = ⇑e.symm\nx✝ : α\n⊢ g (f x✝) = x✝",
"usedConstants": [
"congrArg",
"RelIso.symm_apply_apply",
"Rel... | by simp [hf, hg] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.RelIso.Basic | {
"line": 728,
"column": 17
} | {
"line": 728,
"column": 33
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nδ : Type u_4\nr : α → α → Prop\ns : β → β → Prop\nt : γ → γ → Prop\nu : δ → δ → Prop\ne : r ≃r s\nf : α → β\ng : β → α\nhf : f = ⇑e\nhg : g = ⇑e.symm\nx✝ : β\n⊢ f (g x✝) = x✝",
"usedConstants": [
"congrArg",
"RelIso.symm",
"RelIso",
... | by simp [hf, hg] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Group.Unbundled.Abs | {
"line": 166,
"column": 12
} | {
"line": 166,
"column": 35
} | [
{
"pp": "α : Type u_1\ninst✝² : Lattice α\ninst✝¹ : CommGroup α\ninst✝ : MulLeftMono α\na b c : α\nthis : DistribLattice α := CommGroup.toDistribLattice α\n⊢ |(a ⊔ c) / (b ⊔ c)|ₘ * |(a ⊓ c) / (b ⊓ c)|ₘ = (b ⊔ c ⊔ (a ⊔ c)) / ((b ⊔ c) ⊓ (a ⊔ c)) * |(a ⊓ c) / (b ⊓ c)|ₘ",
"usedConstants": [
"sup_div_inf_e... | sup_div_inf_eq_mabs_div | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Group.Unbundled.Abs | {
"line": 177,
"column": 27
} | {
"line": 177,
"column": 50
} | [
{
"pp": "α : Type u_1\ninst✝² : Lattice α\ninst✝¹ : CommGroup α\ninst✝ : MulLeftMono α\na b c : α\nthis : DistribLattice α := CommGroup.toDistribLattice α\n⊢ (b ⊔ a) / (b ⊓ a) = |a / b|ₘ",
"usedConstants": [
"sup_div_inf_eq_mabs_div",
"Eq.mpr",
"Lattice.toSemilatticeSup",
"instHDiv",... | sup_div_inf_eq_mabs_div | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Hom.Basic | {
"line": 1190,
"column": 4
} | {
"line": 1190,
"column": 47
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝⁴ : Lattice α\ninst✝³ : Lattice β\ninst✝² : BoundedOrder α\ninst✝¹ : BoundedOrder β\ninst✝ : ComplementedLattice α\nf : α ≃o β\nx : β\n⊢ ∃ b, IsCompl x b",
"usedConstants": [
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrde... | obtain ⟨y, hy⟩ := exists_isCompl (f.symm x) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Int.GCD | {
"line": 257,
"column": 4
} | {
"line": 257,
"column": 52
} | [
{
"pp": "case right\na b : ℤ\nha : a ≠ 0\n⊢ ∀ ⦃a_1 : ℕ⦄, 0 < a_1 → a.gcd b ∣ a_1 → a.gcd b ≤ a_1",
"usedConstants": [
"Int.gcd",
"Dvd.dvd",
"instOfNatNat",
"Nat.instDvd",
"Nat",
"LT.lt",
"instLTNat",
"OfNat.ofNat",
"Nat.le_of_dvd"
]
}
] | exact fun n hn_pos hn => Nat.le_of_dvd hn_pos hn | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 146,
"column": 30
} | {
"line": 146,
"column": 38
} | [
{
"pp": "R : Type u\ninst✝⁴ : Semiring R\ninst✝³ : Preorder R\na b : R\ninst✝² : ZeroLEOneClass R\ninst✝¹ : MulPosMono R\ninst✝ : AddLeftMono R\na2 : 2 ≤ a\nb0 : 0 ≤ b\n⊢ a + (a + a * b) ≤ a * (2 + b)",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMon... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 164,
"column": 57
} | {
"line": 164,
"column": 66
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : Preorder R\na b c : R\ninst✝³ : ExistsAddOfLE R\ninst✝² : MulPosMono R\ninst✝¹ : AddRightMono R\ninst✝ : AddRightReflectLE R\nh : b ≤ a\nhc : c ≤ 0\nd : R\nhcd : 0 = c + d\n⊢ b * d + a * 0 = b * d",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Int | {
"line": 93,
"column": 36
} | {
"line": 93,
"column": 50
} | [
{
"pp": "n p q : ℕ\ndvd : ∃ x y, ↑n = ↑(p + 1) * x + ↑(q + 1) * y\nle : p * q ≤ n\na_n b_n : ℤ\neq : ↑n = ↑(p + 1) * a_n + ↑(q + 1) * b_n\na : ℤ := a_n % ↑q.succ\nb : ℤ := b_n + a_n / ↑q.succ * ↑p.succ\nthis : a * ↑p.succ + b * ↑q.succ = ↑n\nhb : b ≤ -1\nha : a_n % ↑q.succ < ↑(↑q.succ).natAbs\n⊢ ↑q * ↑p.succ + ... | Nat.cast_succ, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Order.Ring.Int | {
"line": 93,
"column": 51
} | {
"line": 93,
"column": 59
} | [
{
"pp": "n p q : ℕ\ndvd : ∃ x y, ↑n = ↑(p + 1) * x + ↑(q + 1) * y\nle : p * q ≤ n\na_n b_n : ℤ\neq : ↑n = ↑(p + 1) * a_n + ↑(q + 1) * b_n\na : ℤ := a_n % ↑q.succ\nb : ℤ := b_n + a_n / ↑q.succ * ↑p.succ\nthis : a * ↑p.succ + b * ↑q.succ = ↑n\nhb : b ≤ -1\nha : a_n % ↑q.succ < ↑(↑q.succ).natAbs\n⊢ ↑q * (↑p + 1) +... | mul_add, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 166,
"column": 51
} | {
"line": 166,
"column": 60
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : Preorder R\na b c : R\ninst✝³ : ExistsAddOfLE R\ninst✝² : MulPosMono R\ninst✝¹ : AddRightMono R\ninst✝ : AddRightReflectLE R\nh : b ≤ a\nhc : c ≤ 0\nd : R\nhcd : 0 = c + d\n⊢ a * d = b * 0 + a * d",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 307,
"column": 57
} | {
"line": 307,
"column": 66
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : PartialOrder R\na b c : R\ninst✝³ : ExistsAddOfLE R\ninst✝² : MulPosStrictMono R\ninst✝¹ : AddRightStrictMono R\ninst✝ : AddRightReflectLT R\nh : b < a\nhc : c < 0\nd : R\nhcd : 0 = c + d\n⊢ b * d + a * 0 = b * d",
"usedConstants": [
"Eq.mpr",
"... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 309,
"column": 51
} | {
"line": 309,
"column": 60
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : PartialOrder R\na b c : R\ninst✝³ : ExistsAddOfLE R\ninst✝² : MulPosStrictMono R\ninst✝¹ : AddRightStrictMono R\ninst✝ : AddRightReflectLT R\nh : b < a\nhc : c < 0\nd : R\nhcd : 0 = c + d\n⊢ a * d = b * 0 + a * d",
"usedConstants": [
"Eq.mpr",
"... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 381,
"column": 6
} | {
"line": 381,
"column": 14
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : PartialOrder R\na b c : R\ninst✝³ : ExistsAddOfLE R\ninst✝² : MulPosMono R\ninst✝¹ : AddLeftMono R\ninst✝ : AddLeftReflectLE R\nhab : a ≤ b\nd : R\nhd : 0 ≤ d\nhcd : c ≤ c + d\n⊢ a * (c + d) + b * c ≤ a * c + b * (c + d)",
"usedConstants": [
"Distrib.... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 381,
"column": 31
} | {
"line": 381,
"column": 39
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : PartialOrder R\na b c : R\ninst✝³ : ExistsAddOfLE R\ninst✝² : MulPosMono R\ninst✝¹ : AddLeftMono R\ninst✝ : AddLeftReflectLE R\nhab : a ≤ b\nd : R\nhd : 0 ≤ d\nhcd : c ≤ c + d\n⊢ a * c + b * c + a * d ≤ a * c + b * (c + d)",
"usedConstants": [
"Distri... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 398,
"column": 6
} | {
"line": 398,
"column": 14
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : PartialOrder R\na b c : R\ninst✝³ : AddLeftReflectLT R\ninst✝² : ExistsAddOfLE R\ninst✝¹ : MulPosStrictMono R\ninst✝ : AddLeftStrictMono R\nhab : a < b\nd : R\nhd : 0 < d\nhcd : c < c + d\n⊢ a * (c + d) + b * c < a * c + b * (c + d)",
"usedConstants": [
... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 398,
"column": 31
} | {
"line": 398,
"column": 39
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : PartialOrder R\na b c : R\ninst✝³ : AddLeftReflectLT R\ninst✝² : ExistsAddOfLE R\ninst✝¹ : MulPosStrictMono R\ninst✝ : AddLeftStrictMono R\nhab : a < b\nd : R\nhd : 0 < d\nhcd : c < c + d\n⊢ a * c + b * c + a * d < a * c + b * (c + d)",
"usedConstants": [
... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 697,
"column": 45
} | {
"line": 697,
"column": 54
} | [
{
"pp": "R : Type u\ninst✝⁴ : Semiring R\ninst✝³ : LinearOrder R\ninst✝² : ExistsAddOfLE R\ninst✝¹ : PosMulMono R\ninst✝ : AddLeftMono R\na : R\nha : a < 0\nb : R\nhab : 0 = a + b\nhb : 0 < b\n⊢ b ^ 2 = b ^ 2 + a * 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"MulZeroClass.toMul",
"... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
End of preview. Expand in Data Studio
Mathlib Tactics
This dataset contains tactic invocations with associated goal states from proofs in Mathlib, the mathematical library for the Lean 4 theorem prover, extracted with lean_scout.
Extracted from the Mathlib commit with the following hash.
5e932f97dd25535344f80f9dd8da3aab83df0fe6
The dataset follows this schema:
fields:
- type:
datatype: string
nullable: true
name: module
- type:
datatype: struct
children:
- type:
datatype: nat
nullable: false
name: line
- type:
datatype: nat
nullable: false
name: column
nullable: false
name: startPos
- type:
datatype: struct
children:
- type:
datatype: nat
nullable: false
name: line
- type:
datatype: nat
nullable: false
name: column
nullable: false
name: endPos
- type:
item:
datatype: struct
children:
- type:
datatype: string
nullable: false
name: pp
- type:
item:
datatype: string
datatype: list
nullable: false
name: usedConstants
datatype: list
nullable: false
name: goals
- type:
datatype: string
nullable: false
name: ppTac
- type:
datatype: string
nullable: false
name: elaborator
- type:
datatype: string
nullable: false
name: kind
Attribution
This dataset is derived from Mathlib, an open-source mathematical library developed by the leanprover-community. If you use this dataset, please cite the Mathlib paper or the Mathlib repository.
A full list of Mathlib contributors is available at: https://github.com/leanprover-community/mathlib4/graphs/contributors
- Downloads last month
- 1