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.Algebra.Order.Ring.Unbundled.Basic | {
"line": 698,
"column": 47
} | {
"line": 698,
"column": 55
} | [
{
"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 + a * (a + b) = a ^ 2 + (a * b + b * b)",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mp... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 817,
"column": 20
} | {
"line": 817,
"column": 30
} | [
{
"pp": "R : Type u\ninst✝⁵ : Ring R\ninst✝⁴ : LinearOrder R\na b : R\ninst✝³ : PosMulStrictMono R\ninst✝² : MulPosStrictMono R\ninst✝¹ : AddLeftMono R\ninst✝ : AddLeftReflectLE R\n⊢ 0 ≤ -(a * b) ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a)",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
... | ← mul_neg, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.AddGroupWithTop | {
"line": 278,
"column": 2
} | {
"line": 278,
"column": 42
} | [
{
"pp": "G : Type u_1\ninst✝ : AddCommGroup G\nx y : WithTop G\n⊢ x - y = ⊤ ↔ x = ⊤ ∨ y = ⊤",
"usedConstants": [
"False",
"congrArg",
"WithTop.coe_ne_top._simp_1",
"WithTop.LinearOrderedAddCommGroup.sub_top",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"WithTop.some",
... | cases x <;> cases y <;> simp [← coe_sub] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.Order.AddGroupWithTop | {
"line": 278,
"column": 2
} | {
"line": 278,
"column": 42
} | [
{
"pp": "G : Type u_1\ninst✝ : AddCommGroup G\nx y : WithTop G\n⊢ x - y = ⊤ ↔ x = ⊤ ∨ y = ⊤",
"usedConstants": [
"False",
"congrArg",
"WithTop.coe_ne_top._simp_1",
"WithTop.LinearOrderedAddCommGroup.sub_top",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"WithTop.some",
... | cases x <;> cases y <;> simp [← coe_sub] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.AddGroupWithTop | {
"line": 278,
"column": 2
} | {
"line": 278,
"column": 42
} | [
{
"pp": "G : Type u_1\ninst✝ : AddCommGroup G\nx y : WithTop G\n⊢ x - y = ⊤ ↔ x = ⊤ ∨ y = ⊤",
"usedConstants": [
"False",
"congrArg",
"WithTop.coe_ne_top._simp_1",
"WithTop.LinearOrderedAddCommGroup.sub_top",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"WithTop.some",
... | cases x <;> cases y <;> simp [← coe_sub] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Monoid.Units | {
"line": 53,
"column": 2
} | {
"line": 54,
"column": 5
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Monoid α\ninst✝ : LinearOrder α\na b : αˣ\n⊢ ↑(a ⊓ b) = min ↑a ↑b",
"usedConstants": [
"Units.val_le_val._simp_2",
"Units.val",
"Eq.mpr",
"Units.instMinOfLinearOrder",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Sem... | simp_rw [min_def, val_le_val, ← apply_ite]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Monoid.Units | {
"line": 53,
"column": 2
} | {
"line": 54,
"column": 5
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Monoid α\ninst✝ : LinearOrder α\na b : αˣ\n⊢ ↑(a ⊓ b) = min ↑a ↑b",
"usedConstants": [
"Units.val_le_val._simp_2",
"Units.val",
"Eq.mpr",
"Units.instMinOfLinearOrder",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Sem... | simp_rw [min_def, val_le_val, ← apply_ite]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Sub.Unbundled.Basic | {
"line": 105,
"column": 11
} | {
"line": 105,
"column": 57
} | [
{
"pp": "α : Type u_1\ninst✝⁵ : AddCommSemigroup α\ninst✝⁴ : PartialOrder α\ninst✝³ : ExistsAddOfLE α\ninst✝² : AddLeftMono α\ninst✝¹ : Sub α\ninst✝ : OrderedSub α\na b c : α\nhb : AddLECancellable b\nhba : b ≤ a\nh : a < b + c\n⊢ a - b < c",
"usedConstants": [
"Iff.mpr",
"PartialOrder.toPreorde... | refine (tsub_le_iff_left.mpr h.le).lt_of_ne ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Nat.Cast.Order.Ring | {
"line": 132,
"column": 51
} | {
"line": 132,
"column": 59
} | [
{
"pp": "case succ\nk : ℕ\nhk : 2 * k ^ 2 + 1 ≤ 2 ^ (2 * k)\n⊢ 2 * (k ^ 2 + (2 * k + 1)) + 1 ≤ 2 ^ (2 * (k + 1))",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"HMul.hMul",
"Monoid.toMulOneClass",
... | mul_add, | Mathlib.Tactic.evalGRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Semiring | {
"line": 158,
"column": 31
} | {
"line": 158,
"column": 98
} | [
{
"pp": "case inr\nR : Type u_1\ninst✝³ : Semiring R\ninst✝² : LinearOrder R\ninst✝¹ : FloorSemiring R\ninst✝ : IsStrictOrderedRing R\nn : ℕ\nhn : n ≠ 0\na : R\nha : 0 ≤ a\nm : ℕ\n⊢ ↑m * ↑n ≤ a * ↑n ↔ ↑m ≤ a",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne... | mul_le_mul_iff_of_pos_right (cast_pos'.mpr (zero_lt_of_ne_zero hn)) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Invertible.Basic | {
"line": 90,
"column": 4
} | {
"line": 91,
"column": 14
} | [
{
"pp": "α : Type u\ninst✝² : Monoid α\na b : α\ninst✝¹ : Invertible a\ninst✝ : Invertible (a * b)\n⊢ b * (⅟(a * b) * a) = 1",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"isUnit_of_invertible",
"Monoid.toMulOneClass",
"congrArg",
... | rw [← (isUnit_of_invertible a).mul_right_inj, ← mul_assoc, ← mul_assoc, mul_invOf_self, mul_one,
one_mul] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Invertible.Basic | {
"line": 90,
"column": 4
} | {
"line": 91,
"column": 14
} | [
{
"pp": "α : Type u\ninst✝² : Monoid α\na b : α\ninst✝¹ : Invertible a\ninst✝ : Invertible (a * b)\n⊢ b * (⅟(a * b) * a) = 1",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"isUnit_of_invertible",
"Monoid.toMulOneClass",
"congrArg",
... | rw [← (isUnit_of_invertible a).mul_right_inj, ← mul_assoc, ← mul_assoc, mul_invOf_self, mul_one,
one_mul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Invertible.Basic | {
"line": 90,
"column": 4
} | {
"line": 91,
"column": 14
} | [
{
"pp": "α : Type u\ninst✝² : Monoid α\na b : α\ninst✝¹ : Invertible a\ninst✝ : Invertible (a * b)\n⊢ b * (⅟(a * b) * a) = 1",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"isUnit_of_invertible",
"Monoid.toMulOneClass",
"congrArg",
... | rw [← (isUnit_of_invertible a).mul_right_inj, ← mul_assoc, ← mul_assoc, mul_invOf_self, mul_one,
one_mul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Ring.Invertible | {
"line": 91,
"column": 6
} | {
"line": 91,
"column": 14
} | [
{
"pp": "R : Type u_1\ninst✝² : Semiring R\na b : R\ninst✝¹ : Invertible a\ninst✝ : Invertible b\n⊢ ⅟a + ⅟b = ⅟a * (a + b) * ⅟b",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"congrArg",
"Invertible.invOf... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Invertible | {
"line": 110,
"column": 74
} | {
"line": 110,
"column": 82
} | [
{
"pp": "R : Type u_1\ninst✝³ : Ring R\na b : R\ninst✝² : Invertible a\ninst✝¹ : Invertible b\ninst✝ : Invertible (a + b)\n⊢ 1 = (⅟a + ⅟b) * (a + b) ↔ 1 = ⅟a * a + ⅟b * a + (⅟a * b + ⅟b * b)",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"HMul.hMul",
"Ring.toNonAssocRing"... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.GroupWithZero.Units.Lemmas | {
"line": 113,
"column": 4
} | {
"line": 114,
"column": 46
} | [
{
"pp": "case neg\nG₀ : Type u_3\nG₀' : Type u_5\nF : Type u_6\ninst✝³ : GroupWithZero G₀\ninst✝² : GroupWithZero G₀'\ninst✝¹ : FunLike F G₀ G₀'\ninst✝ : MonoidWithZeroHomClass F G₀ G₀'\nf : F\na : G₀\nh : ¬a = 0\n⊢ f a⁻¹ = (f a)⁻¹",
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",... | apply eq_inv_of_mul_eq_one_left
rw [← map_mul, inv_mul_cancel₀ h, map_one] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.GroupWithZero.Units.Lemmas | {
"line": 113,
"column": 4
} | {
"line": 114,
"column": 46
} | [
{
"pp": "case neg\nG₀ : Type u_3\nG₀' : Type u_5\nF : Type u_6\ninst✝³ : GroupWithZero G₀\ninst✝² : GroupWithZero G₀'\ninst✝¹ : FunLike F G₀ G₀'\ninst✝ : MonoidWithZeroHomClass F G₀ G₀'\nf : F\na : G₀\nh : ¬a = 0\n⊢ f a⁻¹ = (f a)⁻¹",
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",... | apply eq_inv_of_mul_eq_one_left
rw [← map_mul, inv_mul_cancel₀ h, map_one] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Ring.Basic | {
"line": 54,
"column": 21
} | {
"line": 54,
"column": 29
} | [
{
"pp": "R : Type u_3\ninst✝² : Semiring R\ninst✝¹ : PartialOrder R\ninst✝ : IsOrderedRing R\nx y : R\nhx : 0 ≤ x\nhy : 0 ≤ y\nk : ℕ\nih : k + 1 ≠ 0 → x ^ (k + 1) + y ^ (k + 1) ≤ (x + y) ^ (k + 1)\nhn : k + 1 + 1 ≠ 0\nn : ℕ := k.succ\nh1 : 0 ≤ x * y ^ n + y * x ^ n\nh2 : 0 ≤ x + y\n⊢ x * x ^ n + y * y ^ n + (x ... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Basic | {
"line": 54,
"column": 30
} | {
"line": 54,
"column": 38
} | [
{
"pp": "R : Type u_3\ninst✝² : Semiring R\ninst✝¹ : PartialOrder R\ninst✝ : IsOrderedRing R\nx y : R\nhx : 0 ≤ x\nhy : 0 ≤ y\nk : ℕ\nih : k + 1 ≠ 0 → x ^ (k + 1) + y ^ (k + 1) ≤ (x + y) ^ (k + 1)\nhn : k + 1 + 1 ≠ 0\nn : ℕ := k.succ\nh1 : 0 ≤ x * y ^ n + y * x ^ n\nh2 : 0 ≤ x + y\n⊢ x * x ^ n + y * y ^ n + (x ... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Basic | {
"line": 111,
"column": 56
} | {
"line": 111,
"column": 64
} | [
{
"pp": "R : Type u_3\ninst✝³ : Semiring R\ninst✝² : LinearOrder R\ninst✝¹ : IsStrictOrderedRing R\na b : R\ninst✝ : ExistsAddOfLE R\n⊢ a * (a + b) + b * (a + b) = a * a + b * b + (a * b + b * a)",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"HMul.hMul",
"Monoid.toMulOne... | mul_add, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Order.Ring.Basic | {
"line": 128,
"column": 25
} | {
"line": 128,
"column": 33
} | [
{
"pp": "R : Type u_3\ninst✝³ : Semiring R\ninst✝² : LinearOrder R\ninst✝¹ : IsStrictOrderedRing R\na b : R\ninst✝ : ExistsAddOfLE R\nha : 0 ≤ a\nhb : 0 ≤ b\nn : ℕ\n⊢ 2 ^ n * ((a ^ (n + 1) + b ^ (n + 1)) * (a + b)) =\n 2 ^ n * (a ^ (n + 2) + b ^ (n + 2) + (a ^ (n + 1) * b + b ^ (n + 1) * a))",
"usedConst... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Field.Basic | {
"line": 259,
"column": 46
} | {
"line": 259,
"column": 54
} | [
{
"pp": "K : Type u_1\nL : Type u_2\ninst✝¹⁸ : Zero K\ninst✝¹⁷ : Add K\ninst✝¹⁶ : Neg K\ninst✝¹⁵ : Sub K\ninst✝¹⁴ : One K\ninst✝¹³ : Mul K\ninst✝¹² : Inv K\ninst✝¹¹ : Div K\ninst✝¹⁰ : SMul ℕ K\ninst✝⁹ : SMul ℤ K\ninst✝⁸ : SMul ℚ≥0 K\ninst✝⁷ : SMul ℚ K\ninst✝⁶ : Pow K ℕ\ninst✝⁵ : Pow K ℤ\ninst✝⁴ : NatCast K\nins... | intCast, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Basic | {
"line": 144,
"column": 39
} | {
"line": 145,
"column": 74
} | [
{
"pp": "R : Type u_3\ninst✝³ : Semiring R\ninst✝² : LinearOrder R\ninst✝¹ : IsStrictOrderedRing R\na b : R\ninst✝ : ExistsAddOfLE R\nn : ℕ\n⊢ (2 * (a ^ 2 + b ^ 2)) ^ n = 2 ^ n * (a ^ 2 + b ^ 2) ^ n",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
... | by -- TODO: Should be `Nat.cast_commute`
rw [Commute.mul_pow]; simp [Commute, SemiconjBy, two_mul, mul_two] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Ring.Abs | {
"line": 173,
"column": 24
} | {
"line": 173,
"column": 38
} | [
{
"pp": "case succ\nα : Type u_1\ninst✝² : CommRing α\ninst✝¹ : LinearOrder α\na b : α\nn✝ : ℕ\ninst✝ : IsOrderedRing α\nn : ℕ\nih : |geomSum a b n| ≤ (↑n + 1) * max |a| |b| ^ n\n⊢ |a| * |geomSum a b n| + |b| ^ (n + 1) ≤ (↑(n + 1) + 1) * max |a| |b| ^ (n + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Abs | {
"line": 183,
"column": 15
} | {
"line": 183,
"column": 23
} | [
{
"pp": "case succ\nα : Type u_1\ninst✝ : CommRing α\na b : α\nn✝ n : ℕ\nih : a ^ (n + 1) - b ^ (n + 1) = (a - b) * geomSum a b n\n⊢ a ^ (n + 1 + 1) - b ^ (n + 1 + 1) = (a - b) * (a * geomSum a b n + b ^ (n + 1))",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NonUnitalCommRing... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Set.NAry | {
"line": 303,
"column": 6
} | {
"line": 303,
"column": 28
} | [
{
"pp": "α : Type u_1\nβ : Type u_3\nf : α → β → β\na : α\nh : ∀ (b : β), f a b = b\nt : Set β\n⊢ image2 f {a} t = t",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Set.instSingletonSet",
"id",
"Set.image2_singleton_left",
"Set.image2",
"Set.image",
"Singleton.sin... | image2_singleton_left, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.WellFounded | {
"line": 191,
"column": 87
} | {
"line": 195,
"column": 24
} | [
{
"pp": "β : Type u_2\ninst✝¹ : LinearOrder β\ninst✝ : WellFoundedLT β\nf : β → β\nhf : StrictMono f\n⊢ id ≤ f",
"usedConstants": [
"Mathlib.Tactic.Push.not_forall_eq",
"Eq.mpr",
"False",
"Preorder.toLT",
"congrArg",
"Classical.byContradiction",
"PartialOrder.toPreo... | by
rw [Pi.le_def]
by_contra! H
obtain ⟨m, hm, hm'⟩ := wellFounded_lt.has_min {i | f i < i} H
exact hm' _ (hf hm) hm | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Bounds.Image | {
"line": 371,
"column": 4
} | {
"line": 371,
"column": 63
} | [
{
"pp": "case refine_1\nα : Type u_1\nβ : Type u_2\ninst✝¹ : Preorder α\ninst✝ : Preorder β\ns : Set (α × β)\np : α × β\nH : IsLUB s p\na : α\nha : a ∈ upperBounds (Prod.fst '' s)\n⊢ (a, p.2) ∈ upperBounds s",
"usedConstants": [
"Prod.instLE_mathlib",
"lowerBounds",
"Preorder.toLE",
... | exact fun q hq => ⟨ha <| mem_image_of_mem _ hq, (H.1 hq).2⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.Bounds.Basic | {
"line": 304,
"column": 6
} | {
"line": 304,
"column": 19
} | [
{
"pp": "γ : Type u_3\ninst✝ : SemilatticeSup γ\ns : Set γ\nx₀ : γ\n⊢ BddAbove s ↔ ∃ x, x₀ ≤ x ∧ ∀ y ∈ s, y ≤ x",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Exists",
"id",
"LE.le",
"BddAbove",
... | bddAbove_def, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Logic.Equiv.Set | {
"line": 544,
"column": 2
} | {
"line": 545,
"column": 6
} | [
{
"pp": "α : Sort u_3\nβ : Type u_4\nf : α → β\nhf : Injective f\na : α\n⊢ (ofInjective f hf).symm ⟨f a, ⋯⟩ = a",
"usedConstants": [
"Equiv.apply_symm_apply",
"Equiv.instEquivLike",
"congrArg",
"Membership.mem",
"Set.Elem",
"Equiv",
"Equiv.ofLeftInverse._proof_1",
... | apply (ofInjective f hf).injective
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Logic.Equiv.Set | {
"line": 544,
"column": 2
} | {
"line": 545,
"column": 6
} | [
{
"pp": "α : Sort u_3\nβ : Type u_4\nf : α → β\nhf : Injective f\na : α\n⊢ (ofInjective f hf).symm ⟨f a, ⋯⟩ = a",
"usedConstants": [
"Equiv.apply_symm_apply",
"Equiv.instEquivLike",
"congrArg",
"Membership.mem",
"Set.Elem",
"Equiv",
"Equiv.ofLeftInverse._proof_1",
... | apply (ofInjective f hf).injective
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Group.List.Defs | {
"line": 56,
"column": 4
} | {
"line": 58,
"column": 38
} | [
{
"pp": "case cons\nM : Type u_2\ninst✝¹ : Mul M\ninst✝ : One M\nl✝ : List M\np : M → Prop\nhom : ∀ (a b : M), p a → p b → p (a * b)\nunit : p 1\na : M\nl : List M\nih : (∀ (x : M), x ∈ l → p x) → p l.prod\nbase : ∀ (x : M), x ∈ a :: l → p x\n⊢ p (a :: l).prod",
"usedConstants": [
"Eq.mpr",
"HMu... | rw [List.prod_cons]
simp only [mem_cons, forall_eq_or_imp] at base
exact hom _ _ (base.1) (ih base.2) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.List.Defs | {
"line": 56,
"column": 4
} | {
"line": 58,
"column": 38
} | [
{
"pp": "case cons\nM : Type u_2\ninst✝¹ : Mul M\ninst✝ : One M\nl✝ : List M\np : M → Prop\nhom : ∀ (a b : M), p a → p b → p (a * b)\nunit : p 1\na : M\nl : List M\nih : (∀ (x : M), x ∈ l → p x) → p l.prod\nbase : ∀ (x : M), x ∈ a :: l → p x\n⊢ p (a :: l).prod",
"usedConstants": [
"Eq.mpr",
"HMu... | rw [List.prod_cons]
simp only [mem_cons, forall_eq_or_imp] at base
exact hom _ _ (base.1) (ih base.2) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Tactic.FieldSimp.Lemmas | {
"line": 82,
"column": 66
} | {
"line": 86,
"column": 9
} | [
{
"pp": "α : Type u_1\ninst✝ : GroupWithZero α\na : α\nn : ℤ\n⊢ zpow' a (-n) = (zpow' a n)⁻¹",
"usedConstants": [
"Int.instAddCommGroup",
"Eq.mpr",
"inv_eq_zero._simp_1",
"GroupWithZero.toMonoidWithZero",
"MulOne.toOne",
"False",
"NeZero.one",
"GroupWithZero.t... | by
simp +contextual [zpow', apply_ite]
split_ifs with h
· tauto
· tauto | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Field.Basic | {
"line": 123,
"column": 48
} | {
"line": 124,
"column": 65
} | [
{
"pp": "α : Type u_2\ninst✝³ : Semifield α\ninst✝² : PartialOrder α\ninst✝¹ : PosMulReflectLT α\na : α\ninst✝ : IsStrictOrderedRing α\n⊢ a / 2 < a ↔ 0 < a",
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NonAsso... | by
rw [div_lt_iff₀ (zero_lt_two' α), mul_two, lt_add_iff_pos_left] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.BigOperators.Group.List.Basic | {
"line": 270,
"column": 2
} | {
"line": 270,
"column": 64
} | [
{
"pp": "M : Type u_4\ninst✝ : CommMonoid M\nl l' : List M\nh : l.length = l'.length\n⊢ l.prod * l'.prod = (zipWith (fun x1 x2 ↦ x1 * x2) l l').prod",
"usedConstants": [
"MulOne.toOne",
"List.zipWith",
"HMul.hMul",
"Monoid.toMulOneClass",
"MulOne.toMul",
"MulOneClass.toMu... | apply (prod_mul_prod_eq_prod_zipWith_mul_prod_drop l l').trans | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.Order.Field.Basic | {
"line": 699,
"column": 33
} | {
"line": 699,
"column": 41
} | [
{
"pp": "α : Type u_2\ninst✝² : Field α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na b ε : α\nhε : 0 < ε\nh : 2 * (ε * a) * b ≤ (ε * a) ^ 2 + b ^ 2\n⊢ ε⁻¹ * (ε ^ 2 * a ^ 2 + b ^ 2) = ε * a ^ 2 + ε⁻¹ * b ^ 2",
"usedConstants": [
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Rat.Defs | {
"line": 136,
"column": 2
} | {
"line": 136,
"column": 58
} | [
{
"pp": "q r : ℚ\n⊢ q / r = q.num * ↑r.den /. (↑q.den * r.num)",
"usedConstants": [
"Eq.mpr",
"Rat.num",
"instHDiv",
"HMul.hMul",
"congrArg",
"Rat.num_divInt_den",
"Rat",
"Rat.divInt",
"Rat.den",
"Rat.divInt_div_divInt",
"id",
"HDiv.hDi... | rw [← divInt_div_divInt, num_divInt_den, num_divInt_den] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Rat.Defs | {
"line": 136,
"column": 2
} | {
"line": 136,
"column": 58
} | [
{
"pp": "q r : ℚ\n⊢ q / r = q.num * ↑r.den /. (↑q.den * r.num)",
"usedConstants": [
"Eq.mpr",
"Rat.num",
"instHDiv",
"HMul.hMul",
"congrArg",
"Rat.num_divInt_den",
"Rat",
"Rat.divInt",
"Rat.den",
"Rat.divInt_div_divInt",
"id",
"HDiv.hDi... | rw [← divInt_div_divInt, num_divInt_den, num_divInt_den] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Rat.Defs | {
"line": 136,
"column": 2
} | {
"line": 136,
"column": 58
} | [
{
"pp": "q r : ℚ\n⊢ q / r = q.num * ↑r.den /. (↑q.den * r.num)",
"usedConstants": [
"Eq.mpr",
"Rat.num",
"instHDiv",
"HMul.hMul",
"congrArg",
"Rat.num_divInt_den",
"Rat",
"Rat.divInt",
"Rat.den",
"Rat.divInt_div_divInt",
"id",
"HDiv.hDi... | rw [← divInt_div_divInt, num_divInt_den, num_divInt_den] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Basic | {
"line": 349,
"column": 26
} | {
"line": 351,
"column": 67
} | [
{
"pp": "α : Type u\na b : α\nl : List α\nc : α\nhc : c ∈ (a :: b :: l).getLast?\n⊢ (a :: b :: l).dropLast ++ [c] = a :: b :: l",
"usedConstants": [
"Eq.mpr",
"List.dropLast_cons₂",
"List.getLast?",
"List.getLast?_cons_cons",
"congrArg",
"Option.instMembership",
"Me... | by
rw [getLast?_cons_cons] at hc
rw [dropLast_cons₂, cons_append, dropLast_append_getLast? _ hc] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Basic | {
"line": 844,
"column": 2
} | {
"line": 844,
"column": 33
} | [
{
"pp": "α : Type u\nl : List (α → α)\nf : α → α\nhl : ∀ (f : α → α), f ∈ l → Injective f\nhf : Injective f\n⊢ Injective (foldl comp f l)",
"usedConstants": [
"List.mem_cons_of_mem",
"Function.comp",
"Membership.mem",
"List.rec",
"List.foldl",
"List.cons",
"List",
... | induction l generalizing f with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Rat.Lemmas | {
"line": 138,
"column": 2
} | {
"line": 139,
"column": 70
} | [
{
"pp": "q₁ q₂ : ℚ\n⊢ q₁.den * q₂.den = (q₁ * q₂).den * (q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den)",
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
"Rat.instMul",
"Rat.num",
"Dvd.dvd",
"instHDiv",
"Nat.dvd_iff_div_mul_eq",
"HMul.hMul",
"congrArg",
"Ra... | rw [mul_den]
exact ((Nat.dvd_iff_div_mul_eq _ _).mp (Nat.gcd_dvd_right _ _)).symm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Rat.Lemmas | {
"line": 138,
"column": 2
} | {
"line": 139,
"column": 70
} | [
{
"pp": "q₁ q₂ : ℚ\n⊢ q₁.den * q₂.den = (q₁ * q₂).den * (q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den)",
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
"Rat.instMul",
"Rat.num",
"Dvd.dvd",
"instHDiv",
"Nat.dvd_iff_div_mul_eq",
"HMul.hMul",
"congrArg",
"Ra... | rw [mul_den]
exact ((Nat.dvd_iff_div_mul_eq _ _).mp (Nat.gcd_dvd_right _ _)).symm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Rat.Lemmas | {
"line": 239,
"column": 2
} | {
"line": 239,
"column": 25
} | [
{
"pp": "q : ℚ\n⊢ (-q)⁻¹ = -q⁻¹",
"usedConstants": [
"Eq.mpr",
"Rat.num",
"congrArg",
"Rat.num_divInt_den",
"Rat",
"Rat.divInt",
"Rat.den",
"id",
"Int",
"Nat.cast",
"Inv.inv",
"Rat.instInv",
"instNatCastInt",
"Eq.symm",
... | rw [← num_divInt_den q] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Tactic.CancelDenoms.Core | {
"line": 66,
"column": 78
} | {
"line": 67,
"column": 37
} | [
{
"pp": "α : Type u_1\ninst✝ : CommRing α\nn e1 t1 k l : α\ne2 : ℕ\nh1 : n * e1 = t1\nh2 : l * n ^ e2 = k\n⊢ k * e1 ^ e2 = l * t1 ^ e2",
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",... | by
rw [← h2, ← h1, mul_pow, mul_assoc] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Ring.Canonical | {
"line": 99,
"column": 35
} | {
"line": 99,
"column": 44
} | [
{
"pp": "case inl\nR : Type u\ninst✝⁵ : NonUnitalNonAssocSemiring R\ninst✝⁴ : PartialOrder R\ninst✝³ : CanonicallyOrderedAdd R\ninst✝² : Sub R\ninst✝¹ : OrderedSub R\ninst✝ : Std.Total fun x1 x2 ↦ x1 ≤ x2\na b c : R\nh : AddLECancellable (a * c)\nhbc : b ≤ c\n⊢ a * 0 = a * b - a * c",
"usedConstants": [
... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.ConditionallyCompleteLattice.Basic | {
"line": 92,
"column": 4
} | {
"line": 94,
"column": 58
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝¹ : Preorder α\ninst✝ : InfSet α\ns : Set α\nh's : BddBelow s\nx : α\nhx : x ∈ s\nh : (fun a ↦ ↑a) '' s ⊆ {⊤} ∨ ¬BddBelow ((fun a ↦ ↑a) '' s)\n⊢ ↑(sInf s) = ⊤",
"usedConstants": [
"WithTop.coe_mono",
"WithTop.instPreorder",
"Option.ctorIdx",
"HEq... | rcases h with h1 | h2
· cases h1 (mem_image_of_mem _ hx)
· exact (h2 (Monotone.map_bddBelow coe_mono h's)).elim | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.ConditionallyCompleteLattice.Basic | {
"line": 92,
"column": 4
} | {
"line": 94,
"column": 58
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝¹ : Preorder α\ninst✝ : InfSet α\ns : Set α\nh's : BddBelow s\nx : α\nhx : x ∈ s\nh : (fun a ↦ ↑a) '' s ⊆ {⊤} ∨ ¬BddBelow ((fun a ↦ ↑a) '' s)\n⊢ ↑(sInf s) = ⊤",
"usedConstants": [
"WithTop.coe_mono",
"WithTop.instPreorder",
"Option.ctorIdx",
"HEq... | rcases h with h1 | h2
· cases h1 (mem_image_of_mem _ hx)
· exact (h2 (Monotone.map_bddBelow coe_mono h's)).elim | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.CompleteBooleanAlgebra | {
"line": 437,
"column": 2
} | {
"line": 437,
"column": 26
} | [
{
"pp": "case neg\nα : Type u\ninst✝ : Frame α\nι : Type u_1\nf : ι → α\nh : Pairwise (Disjoint on f)\ns t : Set ι\nx✝¹ : ι × ι\ni j : ι\nx✝ : (i, j) ∈ s ×ˢ t\nhis : (i, j).1 ∈ s\nhjs : (i, j).2 ∈ t\nhij : ¬i = j\n⊢ f (i, j).1 ⊓ f (i, j).2 ≤ ⨆ i ∈ s ∩ t, f i",
"usedConstants": [
"CompleteLattice.toLat... | · simp [h hij |>.eq_bot] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.ConditionallyCompleteLattice.Basic | {
"line": 470,
"column": 6
} | {
"line": 470,
"column": 38
} | [
{
"pp": "α : Type u_1\ninst✝ : ConditionallyCompleteLinearOrder α\ns t : Set α\nhs : ∀ x ∈ s, ∃ y ∈ t, x ≤ y\nht : ∀ y ∈ t, ∃ x ∈ s, y ≤ x\ns_ne : s.Nonempty\nt_ne : t.Nonempty\nB : BddAbove s ∨ BddAbove t\nBs : BddAbove s\nBt : BddAbove t\nx : α\nhx : x ∈ s\n⊢ x ≤ sSup t",
"usedConstants": []
}
] | rcases hs x hx with ⟨y, yt, hxy⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Order.ConditionallyCompleteLattice.Basic | {
"line": 653,
"column": 6
} | {
"line": 653,
"column": 42
} | [
{
"pp": "case neg.some\nβ : Type u_5\ninst✝ : ConditionallyCompleteLattice β\ns : Set (WithTop β)\nhs : BddBelow s\nh : ¬s ⊆ {⊤}\na : β\nha : Option.some a ∈ s\n⊢ ↑(sInf ((fun a ↦ ↑a) ⁻¹' s)) ≤ Option.some a",
"usedConstants": [
"Iff.mpr",
"PartialOrder.toPreorder",
"Preorder.toLE",
... | refine coe_le_coe.2 (csInf_le ?_ ha) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Order.ConditionallyCompleteLattice.Basic | {
"line": 669,
"column": 6
} | {
"line": 672,
"column": 60
} | [
{
"pp": "case neg.none\nβ : Type u_5\ninst✝ : ConditionallyCompleteLattice β\ns : Set (WithTop β)\nhs : BddBelow s\nh : ¬s ⊆ {⊤}\nha : none ∈ lowerBounds s\n⊢ none ≤ ↑(sInf ((fun a ↦ ↑a) ⁻¹' s))",
"usedConstants": [
"Iff.mpr",
"WithTop.instPartialOrder",
"WithTop.instPreorder",
"Fals... | · exfalso
apply h
intro b hb
exact Set.mem_singleton_iff.2 (top_le_iff.1 (ha hb)) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.Interval.Set.LinearOrder | {
"line": 97,
"column": 2
} | {
"line": 101,
"column": 40
} | [
{
"pp": "α : Type u_1\ninst✝ : LinearOrder α\nx : α\n⊢ Ici x = {x} ↔ IsTop x",
"usedConstants": [
"Set.ext",
"Preorder.toLT",
"lt_irrefl",
"Set.Ici",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder... | refine ⟨fun h y ↦ ?_, fun h ↦ by ext y; simp [(h y).ge_iff_eq]⟩
by_contra! H
have : y ∈ Ici x := H.le
rw [h, mem_singleton_iff] at this
exact lt_irrefl y (this.le.trans_lt H) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Interval.Set.LinearOrder | {
"line": 97,
"column": 2
} | {
"line": 101,
"column": 40
} | [
{
"pp": "α : Type u_1\ninst✝ : LinearOrder α\nx : α\n⊢ Ici x = {x} ↔ IsTop x",
"usedConstants": [
"Set.ext",
"Preorder.toLT",
"lt_irrefl",
"Set.Ici",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder... | refine ⟨fun h y ↦ ?_, fun h ↦ by ext y; simp [(h y).ge_iff_eq]⟩
by_contra! H
have : y ∈ Ici x := H.le
rw [h, mem_singleton_iff] at this
exact lt_irrefl y (this.le.trans_lt H) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Preorder.Chain | {
"line": 265,
"column": 2
} | {
"line": 265,
"column": 55
} | [
{
"pp": "case false\nα : Type u_1\nr : α → α → Prop\ns : Set α\nh' : s = ∅\nx : α\nh : ∀ ⦃t : Set α⦄, IsChain r t → ∅ = t\n⊢ False",
"usedConstants": [
"IsChain.singleton",
"Set.instSingletonSet",
"Set.instEmptyCollection",
"EmptyCollection.emptyCollection",
"Singleton.singleto... | exact singleton_ne_empty x (h IsChain.singleton).symm | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Notation.Support | {
"line": 61,
"column": 39
} | {
"line": 63,
"column": 88
} | [
{
"pp": "ι : Type u_1\nM : Type u_3\ninst✝ : One M\nf g : ι → M\nx✝ : mulSupport f = mulSupport g ∧ ∀ (x : ι), x ∈ mulSupport f → f x = g x\nh₁ : mulSupport f = mulSupport g\nh₂ : ∀ (x : ι), x ∈ mulSupport f → f x = g x\nx : ι\n⊢ f x = g x",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"congrAr... | by
if hx : x ∈ f.mulSupport then exact h₂ x hx
else rw [notMem_mulSupport.1 hx, notMem_mulSupport.1 (mt (Set.ext_iff.1 h₁ x).2 hx)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Notation.Support | {
"line": 221,
"column": 78
} | {
"line": 221,
"column": 95
} | [
{
"pp": "ι : Type u_1\nM : Type u_3\ninst✝¹ : DecidableEq ι\ninst✝ : One M\ni : ι\na : M\nh : a ≠ 1\nx : ι\nhx : x ∈ {i}\n⊢ mulSingle i a i ≠ 1",
"usedConstants": [
"Eq.mpr",
"Pi.mulSingle_eq_same",
"congrArg",
"id",
"Ne",
"One.toOfNat1",
"OfNat.ofNat",
"Eq",
... | mulSingle_eq_same | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 446,
"column": 22
} | {
"line": 448,
"column": 96
} | [
{
"pp": "n : ℕ\nhn : n ≠ 0\nk : ℕ\nx✝ : 2 ≤ k + 2\n⊢ n.descFactorial (k + 2) < n ^ (k + 2)",
"usedConstants": [
"Nat.pow_succ'",
"instPowNat",
"Eq.mpr",
"HMul.hMul",
"congrArg",
"HSub.hSub",
"id",
"Nat.mul_lt_mul_of_le_of_lt",
"instSubNat",
"instMu... | by
rw [descFactorial_succ, pow_succ', Nat.mul_comm, Nat.mul_comm n]
exact Nat.mul_lt_mul_of_le_of_lt (descFactorial_le_pow _ _) (by lia) (Nat.pow_pos <| by lia) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Rat.Cast.Lemmas | {
"line": 84,
"column": 2
} | {
"line": 84,
"column": 87
} | [
{
"pp": "K : Type u_1\ninst✝ : DivisionRing K\nq : ℚ\nh : 0 ≤ q\n⊢ ↑⟨q, h⟩ = ↑q",
"usedConstants": [
"Rat.instOfNat",
"Int.cast",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Rat.num",
"instHDiv",
"GroupWithZero.toDivInvMonoid",
"NNRat.cast_def",
... | simp only [NNRat.cast_def, NNRat.num_mk, Nat.cast_natAbs, NNRat.den_mk, Rat.cast_def] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Order.Round | {
"line": 55,
"column": 85
} | {
"line": 55,
"column": 93
} | [
{
"pp": "α : Type u_2\ninst✝³ : Ring α\ninst✝² : LinearOrder α\ninst✝¹ : IsStrictOrderedRing α\ninst✝ : FloorRing α\nx : α\n⊢ (if 2 * fract x < 1 then ⌊x⌋ + ⌊fract x⌋ else ⌈↑⌊x⌋ + fract x⌉) = (⌊2 * (↑⌊x⌋ + fract x)⌋ + 1) / 2",
"usedConstants": [
"Distrib.leftDistribClass",
"Int.cast",
"Eq.... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Basic | {
"line": 34,
"column": 2
} | {
"line": 34,
"column": 71
} | [
{
"pp": "n : ℕ+\n⊢ 1 + n.natPred = ↑n",
"usedConstants": [
"PNat.val",
"Iff.mpr",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Nat.instOrderedSub",
"PNat.natPred.eq_1",
"add_tsub_cancel_iff_le",
"congrArg",
"PartialOrder.toPreorder",
"HSub.hSub",
... | rw [natPred, add_tsub_cancel_iff_le.mpr <| show 1 ≤ (n : ℕ) from n.2] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.PNat.Basic | {
"line": 34,
"column": 2
} | {
"line": 34,
"column": 71
} | [
{
"pp": "n : ℕ+\n⊢ 1 + n.natPred = ↑n",
"usedConstants": [
"PNat.val",
"Iff.mpr",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Nat.instOrderedSub",
"PNat.natPred.eq_1",
"add_tsub_cancel_iff_le",
"congrArg",
"PartialOrder.toPreorder",
"HSub.hSub",
... | rw [natPred, add_tsub_cancel_iff_le.mpr <| show 1 ≤ (n : ℕ) from n.2] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PNat.Basic | {
"line": 34,
"column": 2
} | {
"line": 34,
"column": 71
} | [
{
"pp": "n : ℕ+\n⊢ 1 + n.natPred = ↑n",
"usedConstants": [
"PNat.val",
"Iff.mpr",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Nat.instOrderedSub",
"PNat.natPred.eq_1",
"add_tsub_cancel_iff_le",
"congrArg",
"PartialOrder.toPreorder",
"HSub.hSub",
... | rw [natPred, add_tsub_cancel_iff_le.mpr <| show 1 ≤ (n : ℕ) from n.2] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.PNat.Basic | {
"line": 286,
"column": 16
} | {
"line": 286,
"column": 25
} | [
{
"pp": "m k : ℕ+\nh₀ : 0 + ↑k * 0 = ↑m\nhr : ↑m % ↑k = 0\nhq : ↑m / ↑k = 0\n⊢ False",
"usedConstants": [
"PNat.val",
"Nat.instMulZeroClass",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"Eq.mp",
"instOfNatNat",
"MulZeroClass.mul_zero",
"instHAdd",
... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 490,
"column": 22
} | {
"line": 490,
"column": 30
} | [
{
"pp": "case succ\nR : Type u_2\ninst✝³ : Ring R\ninst✝² : LinearOrder R\ninst✝¹ : FloorRing R\ninst✝ : IsStrictOrderedRing R\na : R\nc : ℕ\nz : ℤ\nhz : fract a * ↑c - fract (a * ↑c) = ↑z\n⊢ ∃ z, fract a * (↑c + ↑1) - fract (a * (↑c + ↑1)) = ↑z",
"usedConstants": [
"Distrib.leftDistribClass",
"... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 490,
"column": 31
} | {
"line": 490,
"column": 39
} | [
{
"pp": "case succ\nR : Type u_2\ninst✝³ : Ring R\ninst✝² : LinearOrder R\ninst✝¹ : FloorRing R\ninst✝ : IsStrictOrderedRing R\na : R\nc : ℕ\nz : ℤ\nhz : fract a * ↑c - fract (a * ↑c) = ↑z\n⊢ ∃ z, fract a * ↑c + fract a * ↑1 - fract (a * (↑c + ↑1)) = ↑z",
"usedConstants": [
"Distrib.leftDistribClass",... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 543,
"column": 81
} | {
"line": 543,
"column": 89
} | [
{
"pp": "case inr.refine_3\nk : Type u_4\ninst✝³ : Field k\ninst✝² : LinearOrder k\ninst✝¹ : IsStrictOrderedRing k\ninst✝ : FloorRing k\nm n : ℕ\nhn : n > 0\nhn' : 0 < ↑n\n⊢ ↑m = ↑n * (↑(m % n) / ↑n + ↑(↑m / ↑n))",
"usedConstants": [
"Distrib.leftDistribClass",
"Int.cast",
"Eq.mpr",
... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 642,
"column": 64
} | {
"line": 643,
"column": 81
} | [
{
"pp": "R : Type u_2\ninst✝³ : Ring R\ninst✝² : LinearOrder R\ninst✝¹ : FloorRing R\ninst✝ : IsStrictOrderedRing R\na : R\nz : ℤ\n⊢ ⌈a + ↑z⌉ = ⌈a⌉ + z",
"usedConstants": [
"Int.instAddCommGroup",
"Int.cast",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonUnitalCommRing.toNonUnitalNonAsso... | by
rw [← neg_inj, neg_add', ← floor_neg, ← floor_neg, neg_add', floor_sub_intCast] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 768,
"column": 6
} | {
"line": 769,
"column": 28
} | [
{
"pp": "k : Type u_4\ninst✝³ : Field k\ninst✝² : LinearOrder k\ninst✝¹ : IsStrictOrderedRing k\ninst✝ : FloorRing k\na b : k\nhb₀ : 0 < b\nhb : b < 1\nhba : ↑⌈b / (1 - b)⌉ ≤ a\n⊢ b * (↑⌊a⌋ + 1) ≤ ↑⌊a⌋",
"usedConstants": [
"Distrib.leftDistribClass",
"Int.cast",
"Eq.mpr",
"GroupWithZ... | rwa [_root_.mul_add_one, ← le_sub_iff_add_le', ← one_sub_mul, ← div_le_iff₀' (by linarith),
← ceil_le, le_floor] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 768,
"column": 6
} | {
"line": 769,
"column": 28
} | [
{
"pp": "k : Type u_4\ninst✝³ : Field k\ninst✝² : LinearOrder k\ninst✝¹ : IsStrictOrderedRing k\ninst✝ : FloorRing k\na b : k\nhb₀ : 0 < b\nhb : b < 1\nhba : ↑⌈b / (1 - b)⌉ ≤ a\n⊢ b * (↑⌊a⌋ + 1) ≤ ↑⌊a⌋",
"usedConstants": [
"Distrib.leftDistribClass",
"Int.cast",
"Eq.mpr",
"GroupWithZ... | rwa [_root_.mul_add_one, ← le_sub_iff_add_le', ← one_sub_mul, ← div_le_iff₀' (by linarith),
← ceil_le, le_floor] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 768,
"column": 6
} | {
"line": 769,
"column": 28
} | [
{
"pp": "k : Type u_4\ninst✝³ : Field k\ninst✝² : LinearOrder k\ninst✝¹ : IsStrictOrderedRing k\ninst✝ : FloorRing k\na b : k\nhb₀ : 0 < b\nhb : b < 1\nhba : ↑⌈b / (1 - b)⌉ ≤ a\n⊢ b * (↑⌊a⌋ + 1) ≤ ↑⌊a⌋",
"usedConstants": [
"Distrib.leftDistribClass",
"Int.cast",
"Eq.mpr",
"GroupWithZ... | rwa [_root_.mul_add_one, ← le_sub_iff_add_le', ← one_sub_mul, ← div_le_iff₀' (by linarith),
← ceil_le, le_floor] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Archimedean.Basic | {
"line": 451,
"column": 45
} | {
"line": 451,
"column": 59
} | [
{
"pp": "K : Type u_4\ninst✝³ : Field K\ninst✝² : LinearOrder K\ninst✝¹ : IsStrictOrderedRing K\ninst✝ : Archimedean K\nn : ℕ\nhn : n ≠ 0\nx y : K\nh : x < y\nhy : 0 < y\nδ : K\nδ_pos : δ > 0\ncont : ∀ (q r : K), |r| ≤ max 1 y → |q - r| ≤ δ → |q ^ n - r ^ n| < y - max x 0\nex : ∃ m, y ≤ (↑m * δ) ^ n\nm : ℕ := N... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Nodup | {
"line": 115,
"column": 4
} | {
"line": 115,
"column": 47
} | [
{
"pp": "case pos\nα : Type u\nx hd : α\ntl : List α\nh : (hd :: tl).Nodup\nhl : tl ≠ [x] ↔ tl = [] ∨ ∃ y, y ∈ tl ∧ y ≠ x\nhx : tl = [x]\n⊢ hd :: tl ≠ [x] ↔ hd :: tl = [] ∨ ∃ y, y ∈ hd :: tl ∧ y ≠ x",
"usedConstants": [
"_private.Mathlib.Data.List.Nodup.0.List.Nodup.ne_singleton_iff._simp_1_2",
... | · simpa [hx, and_comm, and_or_left] using h | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.List.Nodup | {
"line": 256,
"column": 8
} | {
"line": 257,
"column": 39
} | [
{
"pp": "case neg\nα : Type u\na : α\nl : List α\nih : l[0]? = l.getLast? → (l.dropLast.Nodup ↔ l.tail.Nodup)\nhl : ¬l = []\nh : a = l[l.length - 1]\n⊢ (l[l.length - 1] :: l.dropLast).Nodup ↔ l.Nodup",
"usedConstants": [
"List.getLast",
"Nat.succ_lt_succ_iff",
"Eq.mpr",
"List.take_ap... | show l.Nodup = (l.dropLast ++ [l.getLast hl]).Nodup by
simp [List.dropLast_eq_take], | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Multiset.AddSub | {
"line": 187,
"column": 2
} | {
"line": 187,
"column": 39
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : Multiset α\na : α\n⊢ s + {a} = t ↔ a ∈ t ∧ s = t.erase a",
"usedConstants": [
"Eq.mpr",
"Multiset.singleton_add",
"congrArg",
"Multiset.add_comm",
"Membership.mem",
"Multiset",
"Multiset.cons",
"id",
"M... | rw [Multiset.add_comm, singleton_add] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.List.Dedup | {
"line": 124,
"column": 2
} | {
"line": 124,
"column": 29
} | [
{
"pp": "case cons\nα : Type u_1\ninst✝ : DecidableEq α\nl₂ : List α\na : α\nl₁ : List α\nIH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup\n⊢ (a :: l₁ ++ l₂).dedup = a :: l₁ ∪ l₂.dedup",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.cons_union",
"List.dedup",
"id",
"instBEqOfDecida... | simp only [cons_union] at * | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Dedup | {
"line": 127,
"column": 8
} | {
"line": 127,
"column": 29
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : DecidableEq α\nl₂ : List α\na : α\nl₁ : List α\nIH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup\nh : a ∈ (l₁ ++ l₂).dedup\n⊢ (a :: (l₁ ++ l₂)).dedup = List.insert a (l₁ ++ l₂).dedup",
"usedConstants": [
"Eq.mpr",
"List.dedup_cons_of_mem'",
"congrArg",
"... | dedup_cons_of_mem' h, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Multiset.Dedup | {
"line": 116,
"column": 31
} | {
"line": 118,
"column": 81
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : Multiset α\nh : s ⊆ t\n⊢ (s + t).dedup = t.dedup",
"usedConstants": [
"Multiset.instHasSubset",
"Multiset.dedup",
"List.dedup",
"Multiset",
"List.Subset.dedup_append_right",
"HasSubset.Subset",
"Quot.induction_on₂"... | by
induction s, t using Quot.induction_on₂
exact congr_arg ((↑) : List α → Multiset α) <| List.Subset.dedup_append_right h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.Insert | {
"line": 186,
"column": 76
} | {
"line": 187,
"column": 66
} | [
{
"pp": "α : Type u_1\ns : Finset α\na : α\nha : a ∈ s\n⊢ s = {a} ∨ s.Nontrivial",
"usedConstants": [
"Finset.coe_eq_singleton",
"Eq.mpr",
"congrArg",
"Finset",
"Set.instSingletonSet",
"id",
"SetLike.coe",
"Finset.instSetLike",
"Finset.Nontrivial",
... | by
rw [← coe_eq_singleton]; exact Set.eq_singleton_or_nontrivial ha | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.Lattice.Lemmas | {
"line": 125,
"column": 4
} | {
"line": 126,
"column": 56
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns₁ s₂ : Finset α\na : α\nh : a ∈ s₂\nx : α\n⊢ x ∈ insert a s₁ ∩ s₂ ↔ x ∈ insert a (s₁ ∩ s₂)",
"usedConstants": [
"congrArg",
"Finset",
"Membership.mem",
"Insert.insert",
"_private.Mathlib.Data.Finset.Lattice.Lemmas.0.Finset.insert_i... | have : x = a ∨ x ∈ s₂ ↔ x ∈ s₂ := or_iff_right_of_imp <| by rintro rfl; exact h
simp only [mem_inter, mem_insert, or_and_left, this] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Lattice.Lemmas | {
"line": 125,
"column": 4
} | {
"line": 126,
"column": 56
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns₁ s₂ : Finset α\na : α\nh : a ∈ s₂\nx : α\n⊢ x ∈ insert a s₁ ∩ s₂ ↔ x ∈ insert a (s₁ ∩ s₂)",
"usedConstants": [
"congrArg",
"Finset",
"Membership.mem",
"Insert.insert",
"_private.Mathlib.Data.Finset.Lattice.Lemmas.0.Finset.insert_i... | have : x = a ∨ x ∈ s₂ ↔ x ∈ s₂ := or_iff_right_of_imp <| by rintro rfl; exact h
simp only [mem_inter, mem_insert, or_and_left, this] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Basic | {
"line": 173,
"column": 2
} | {
"line": 173,
"column": 46
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : Finset α\na : α\nh : a ∈ t\n⊢ s.erase a ⊆ t ↔ s ⊆ t",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"Iff.rfl",
"id",
"Insert.insert",
"HasSubset.Subset",
"Finset.instInsert",
"Iff",
"Finset.i... | rw [← subset_insert_iff, insert_eq_of_mem h] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Finset.Basic | {
"line": 173,
"column": 2
} | {
"line": 173,
"column": 46
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : Finset α\na : α\nh : a ∈ t\n⊢ s.erase a ⊆ t ↔ s ⊆ t",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"Iff.rfl",
"id",
"Insert.insert",
"HasSubset.Subset",
"Finset.instInsert",
"Iff",
"Finset.i... | rw [← subset_insert_iff, insert_eq_of_mem h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Basic | {
"line": 173,
"column": 2
} | {
"line": 173,
"column": 46
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : Finset α\na : α\nh : a ∈ t\n⊢ s.erase a ⊆ t ↔ s ⊆ t",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"Iff.rfl",
"id",
"Insert.insert",
"HasSubset.Subset",
"Finset.instInsert",
"Iff",
"Finset.i... | rw [← subset_insert_iff, insert_eq_of_mem h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.BooleanAlgebra | {
"line": 55,
"column": 65
} | {
"line": 56,
"column": 38
} | [
{
"pp": "α : Type u_1\ninst✝ : Fintype α\n⊢ univ = ∅ ↔ IsEmpty α",
"usedConstants": [
"Eq.mpr",
"Mathlib.Tactic.Contrapose.contrapose_iff₁",
"Finset.univ",
"congrArg",
"Finset",
"id",
"IsEmpty",
"Finset.instEmptyCollection",
"Iff",
"congr",
"... | by
contrapose!; exact univ_nonempty_iff | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.BooleanAlgebra | {
"line": 266,
"column": 52
} | {
"line": 266,
"column": 72
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝² : Fintype α\nf : α → β\np : α → Prop\ninst✝¹ : DecidablePred p\ninst✝ : Fintype { a // p a }\n⊢ Multiset.map (Subtype.restrict p f) univ.val = Multiset.map (f ∘ Subtype.val) univ.val",
"usedConstants": [
"Eq.mpr",
"Finset.univ",
"Multiset.map",
... | Subtype.restrict_def | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Finset.Image | {
"line": 350,
"column": 18
} | {
"line": 350,
"column": 77
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝¹ : DecidableEq β\nf : α → β\ns : Finset α\ninst✝ : DecidableEq γ\ng : β → γ\n⊢ (image g (image f s)).val = (image (g ∘ f) s).val",
"usedConstants": [
"Multiset.map",
"congrArg",
"Multiset.dedup",
"Function.comp",
"Multise... | simp only [image_val, dedup_map_dedup_eq, Multiset.map_map] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Finset.Image | {
"line": 350,
"column": 18
} | {
"line": 350,
"column": 77
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝¹ : DecidableEq β\nf : α → β\ns : Finset α\ninst✝ : DecidableEq γ\ng : β → γ\n⊢ (image g (image f s)).val = (image (g ∘ f) s).val",
"usedConstants": [
"Multiset.map",
"congrArg",
"Multiset.dedup",
"Function.comp",
"Multise... | simp only [image_val, dedup_map_dedup_eq, Multiset.map_map] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Image | {
"line": 350,
"column": 18
} | {
"line": 350,
"column": 77
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝¹ : DecidableEq β\nf : α → β\ns : Finset α\ninst✝ : DecidableEq γ\ng : β → γ\n⊢ (image g (image f s)).val = (image (g ∘ f) s).val",
"usedConstants": [
"Multiset.map",
"congrArg",
"Multiset.dedup",
"Function.comp",
"Multise... | simp only [image_val, dedup_map_dedup_eq, Multiset.map_map] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Fin.Basic | {
"line": 396,
"column": 9
} | {
"line": 396,
"column": 32
} | [
{
"pp": "case h.refine_2\nm n : ℕ\ne : Fin n ≃o Fin m\ni : ℕ\nh : ∀ (m_1 : ℕ), m_1 < i → ∀ (hi : m_1 < n), ↑(e ⟨m_1, hi⟩) = m_1\nhi : i < n\nj : ℕ\nhj : j < i\n⊢ j < ↑(e ⟨i, hi⟩)",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"PartialOrder.toPreorder",
"Fin.mk",
... | ← h j hj (hj.trans hi), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fin.SuccPred | {
"line": 251,
"column": 2
} | {
"line": 251,
"column": 21
} | [
{
"pp": "n : ℕ\ni : Fin n.succ\nhi : i ∈ Set.range castSucc\n⊢ ↑((Equiv.ofInjective castSucc ⋯).symm ⟨i, hi⟩) = ↑i",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"congrArg",
"Membership.mem",
"Set.Elem",
"id",
"Equiv",
"Fin.castSucc_injective",
"i... | rw [← val_castSucc] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.List.Duplicate | {
"line": 67,
"column": 2
} | {
"line": 67,
"column": 23
} | [
{
"pp": "case cons_duplicate\nα : Type u_1\nl : List α\nx y y✝ : α\nl✝ : List α\nh : x ∈+ l✝\na_ih✝ : l✝ ≠ [y]\n⊢ y✝ :: l✝ ≠ [y]",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"List.ne_nil_of_mem",
"List.Duplicate.mem",
"List.cons",
"List.cons.injEq",
"... | | cons_duplicate h => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Finset.Card | {
"line": 651,
"column": 2
} | {
"line": 651,
"column": 69
} | [
{
"pp": "α : Type u_1\ns : Finset α\nn : ℕ\nhns : n ≤ #s\n⊢ ∃ t ⊆ s, #t = n",
"usedConstants": [
"congrArg",
"Finset",
"Exists",
"Eq.mp",
"HasSubset.Subset",
"instOfNatNat",
"LE.le",
"instLENat",
"Finset.empty_subset._simp_1",
"Finset.instEmptyColl... | simpa using exists_subsuperset_card_eq s.empty_subset (by simp) hns | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Data.Finset.Card | {
"line": 651,
"column": 2
} | {
"line": 651,
"column": 69
} | [
{
"pp": "α : Type u_1\ns : Finset α\nn : ℕ\nhns : n ≤ #s\n⊢ ∃ t ⊆ s, #t = n",
"usedConstants": [
"congrArg",
"Finset",
"Exists",
"Eq.mp",
"HasSubset.Subset",
"instOfNatNat",
"LE.le",
"instLENat",
"Finset.empty_subset._simp_1",
"Finset.instEmptyColl... | simpa using exists_subsuperset_card_eq s.empty_subset (by simp) hns | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Card | {
"line": 651,
"column": 2
} | {
"line": 651,
"column": 69
} | [
{
"pp": "α : Type u_1\ns : Finset α\nn : ℕ\nhns : n ≤ #s\n⊢ ∃ t ⊆ s, #t = n",
"usedConstants": [
"congrArg",
"Finset",
"Exists",
"Eq.mp",
"HasSubset.Subset",
"instOfNatNat",
"LE.le",
"instLENat",
"Finset.empty_subset._simp_1",
"Finset.instEmptyColl... | simpa using exists_subsuperset_card_eq s.empty_subset (by simp) hns | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.NodupEquivFin | {
"line": 137,
"column": 10
} | {
"line": 137,
"column": 35
} | [
{
"pp": "α : Type u_1\nhd : α\ntl : List α\nIH : ∀ {l' : List α} (f : ℕ ↪o ℕ), (∀ (ix : ℕ), tl[ix]? = l'[f ix]?) → tl <+ l'\nl' : List α\nf : ℕ ↪o ℕ\nhf : ∀ (ix : ℕ), (hd :: tl)[ix]? = l'[f ix]?\nw : f 0 < l'.length\nh : l'[f 0] = hd\na b : ℕ\n⊢ f (a + 1) - (f 0 + 1) ≤ f (b + 1) - (f 0 + 1) ↔ a ≤ b",
"usedC... | Nat.sub_le_sub_iff_right, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 916,
"column": 80
} | {
"line": 917,
"column": 69
} | [
{
"pp": "n : ℕ\nα : Fin (n + 1) → Sort u_1\ni j : Fin (n + 1)\nh : j < i\nx : α i\np : (k : Fin n) → α (i.succAbove k)\n⊢ i.insertNth x p j = ⋯ ▸ p (j.castPred ⋯)",
"usedConstants": [
"Fin.succAbove",
"Eq.mpr",
"Fin.succAboveCases",
"Fin.succAboveCases._proof_1",
"Fin.pred",
... | by
rw [insertNth, succAboveCases, dif_neg (Fin.ne_of_lt h), dif_pos h] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.NodupEquivFin | {
"line": 164,
"column": 6
} | {
"line": 164,
"column": 20
} | [
{
"pp": "case mp.cons\nα : Type u_1\nl l' l₁✝ l₂✝ : List α\na✝¹ : α\na✝ : l₁✝ <+ l₂✝\nf : ℕ ↪o ℕ\nhf : ∀ (ix : ℕ), l₁✝[ix]? = l₂✝[f ix]?\n⊢ ∀ (ix : ℕ), l₁✝[ix]? = (a✝¹ :: l₂✝)[(RelEmbedding.trans f (OrderEmbedding.ofStrictMono (fun x ↦ x + 1) ⋯)) ix]?",
"usedConstants": [
"Preorder.toLT",
"Parti... | simpa using hf | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Data.List.NodupEquivFin | {
"line": 233,
"column": 10
} | {
"line": 233,
"column": 100
} | [
{
"pp": "case mpr.refine_1.succ.succ\nα : Type u_1\nl : List α\nx : α\nn m : Fin l.length\nhnm : n < m\nh : x = l.get n\nh' : x = l.get m\nn✝¹ : ℕ\nhi : n✝¹ + 1 < (replicate 2 x).length\nn✝ : ℕ\nhj : n✝ + 1 < (replicate 2 x).length\n⊢ ⟨n✝¹ + 1, hi⟩ < ⟨n✝ + 1, hj⟩ →\n (fun i ↦ if ↑i = 0 then n else m) ⟨n✝¹ + ... | simp only [Nat.lt_succ_iff, Nat.succ_le_succ_iff, replicate, length, Nat.le_zero] at hi hj | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.