module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.Algebra.Group.Units.Basic | {
"line": 162,
"column": 15
} | {
"line": 162,
"column": 23
} | [
{
"pp": "α : Type u\ninst✝ : Monoid α\nu : αˣ\n⊢ ↑u⁻¹ = 1 /ₚ u",
"usedConstants": [
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"DivInvMonoid.toInv",
"Monoid.toMulOneClass",
"congrArg",
"Units",
"id",
"Units.instDivInvMonoid",
"divp",
"one_divp",
... | one_divp | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.GroupWithZero.NeZero | {
"line": 30,
"column": 2
} | {
"line": 30,
"column": 10
} | [
{
"pp": "M₀ : Type u_1\nM₀' : Type u_2\ninst✝¹ : MulZeroOneClass M₀\ninst✝ : Nontrivial M₀\nh : 1 = 0\nx y : M₀\nhx : x ≠ y\n⊢ False",
"usedConstants": []
}
] | apply hx | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.Ring.Basic | {
"line": 243,
"column": 52
} | {
"line": 244,
"column": 86
} | [
{
"pp": "α : Type u_3\ninst✝ : Ring α\n⊢ IsDomain α ↔ NoZeroDivisors α ∧ Nontrivial α",
"usedConstants": [
"Nontrivial",
"Eq.mpr",
"IsDomain",
"isDomain_iff_cancelMulZero_and_nontrivial",
"Ring.toNonAssocRing",
"congrArg",
"Iff.rfl",
"NonUnitalNonAssocSemiring... | by
rw [← isCancelMulZero_iff_noZeroDivisors, isDomain_iff_cancelMulZero_and_nontrivial] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Commute.Units | {
"line": 161,
"column": 41
} | {
"line": 163,
"column": 77
} | [
{
"pp": "M : Type u_1\ninst✝ : DivisionMonoid M\na b c d : M\nhbd : Commute b d\nhb : IsUnit b\nhd : IsUnit d\n⊢ b⁻¹ * a = d⁻¹ * c ↔ d * a = b * c",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"DivInvMonoid.toInv",
"Commute.left_comm",
"HMul.hMul",
... | by
rw [← (hd.mul hb).mul_right_inj, ← mul_assoc, mul_assoc d, hb.mul_inv_cancel, mul_one,
← mul_assoc, mul_assoc d, hbd.symm.left_comm, hd.mul_inv_cancel, mul_one] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Monoid.Unbundled.Defs | {
"line": 427,
"column": 2
} | {
"line": 427,
"column": 18
} | [
{
"pp": "M : Type u_1\nN : Type u_2\nμ : M → N → N\ninst✝ : PartialOrder N\n⊢ (Covariant M N μ fun x1 x2 ↦ x1 < x2) → Covariant M N μ fun x1 x2 ↦ x1 ≤ x2",
"usedConstants": [
"Preorder.toLT",
"PartialOrder.toPreorder",
"Covariant",
"LT.lt"
]
}
] | intro h a b c bc | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Algebra.Order.Group.Unbundled.Basic | {
"line": 191,
"column": 2
} | {
"line": 191,
"column": 53
} | [
{
"pp": "α : Type u\ninst✝² : Group α\ninst✝¹ : LT α\ninst✝ : MulRightStrictMono α\na b c : α\n⊢ a * b⁻¹ < c ↔ a < c * b",
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Iff.rfl",... | rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Group.Unbundled.Basic | {
"line": 191,
"column": 2
} | {
"line": 191,
"column": 53
} | [
{
"pp": "α : Type u\ninst✝² : Group α\ninst✝¹ : LT α\ninst✝ : MulRightStrictMono α\na b c : α\n⊢ a * b⁻¹ < c ↔ a < c * b",
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Iff.rfl",... | rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Group.Unbundled.Basic | {
"line": 191,
"column": 2
} | {
"line": 191,
"column": 53
} | [
{
"pp": "α : Type u\ninst✝² : Group α\ninst✝¹ : LT α\ninst✝ : MulRightStrictMono α\na b c : α\n⊢ a * b⁻¹ < c ↔ a < c * b",
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Iff.rfl",... | rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Group.Unbundled.Basic | {
"line": 696,
"column": 2
} | {
"line": 696,
"column": 38
} | [
{
"pp": "α : Type u\ninst✝² : CommGroup α\ninst✝¹ : Preorder α\ninst✝ : MulLeftStrictMono α\na b c d : α\nhab : a < b\nhcd : c < d\n⊢ a * c < b * d",
"usedConstants": [
"Preorder.toLT",
"CommMonoid.toCommSemigroup",
"CommMagma.toMul",
"mul_lt_mul_of_lt_of_lt",
"LT.lt",
"C... | exact mul_lt_mul_of_lt_of_lt hab hcd | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.Monoid.Defs | {
"line": 37,
"column": 33
} | {
"line": 37,
"column": 62
} | [
{
"pp": "α✝ : Type u_1\nα : Type u_2\ninst✝¹ : CommMonoid α\ninst✝ : Preorder α\nmul_le_mul_left : ∀ (a b : α), a ≤ b → ∀ (c : α), a * c ≤ b * c\na b : α\nh : a ≤ b\nc : α\n⊢ a * c ≤ b * c",
"usedConstants": []
}
] | exact mul_le_mul_left a b h c | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.Group.Defs | {
"line": 90,
"column": 4
} | {
"line": 90,
"column": 56
} | [
{
"pp": "α : Type u\ninst✝³ : CommGroup α\ninst✝² : LinearOrder α\ninst✝¹ : IsOrderedMonoid α\na : α\ninst✝ : Nontrivial α\ny : α\nhy : 1 < y\n⊢ ∀ (a : α), ∃ b, a < b",
"usedConstants": [
"Preorder.toLT",
"HMul.hMul",
"Monoid.toMulOneClass",
"IsLeftCancelMul.mulLeftStrictMono_of_mulL... | exact fun a => ⟨a * y, lt_mul_of_one_lt_right' a hy⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.RelIso.Basic | {
"line": 234,
"column": 78
} | {
"line": 235,
"column": 28
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nr : α → α → Prop\ns : β → β → Prop\n⊢ Injective toEmbedding",
"usedConstants": [
"RelEmbedding.mk",
"RelEmbedding.mk.injEq",
"RelEmbedding.casesOn",
"RelEmbedding.toEmbedding",
"imp_self._simp_1",
"Function.Embedding",
"RelEmbedd... | by
rintro ⟨f, -⟩ ⟨g, -⟩; simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.RelIso.Basic | {
"line": 673,
"column": 30
} | {
"line": 676,
"column": 7
} | [
{
"pp": "α✝ : Type u_1\nβ✝ : Type u_2\nγ : Type u_3\nδ : Type u_4\nr✝ : α✝ → α✝ → Prop\ns✝ : β✝ → β✝ → Prop\nt : γ → γ → Prop\nu : δ → δ → Prop\nα β : Type u\nr : α → α → Prop\ns : β → β → Prop\nh₁ : α = β\nh₂ : r ≍ s\na b : α\n⊢ s ((Equiv.cast h₁) a) ((Equiv.cast h₁) b) ↔ r a b",
"usedConstants": [
"... | by
subst h₁
rw [eq_of_heq h₂]
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 397,
"column": 2
} | {
"line": 400,
"column": 10
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : PartialOrder R\na b c d : R\ninst✝³ : AddLeftReflectLT R\ninst✝² : ExistsAddOfLE R\ninst✝¹ : MulPosStrictMono R\ninst✝ : AddLeftStrictMono R\nhab : a < b\nhcd : c < d\n⊢ a * d + b * c < a * c + b * d",
"usedConstants": [
"Distrib.leftDistribClass",
... | obtain ⟨d, hd, rfl⟩ := exists_pos_add_of_lt' hcd
rw [mul_add, add_right_comm, mul_add, ← add_assoc]
gcongr
exact hd | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 397,
"column": 2
} | {
"line": 400,
"column": 10
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : PartialOrder R\na b c d : R\ninst✝³ : AddLeftReflectLT R\ninst✝² : ExistsAddOfLE R\ninst✝¹ : MulPosStrictMono R\ninst✝ : AddLeftStrictMono R\nhab : a < b\nhcd : c < d\n⊢ a * d + b * c < a * c + b * d",
"usedConstants": [
"Distrib.leftDistribClass",
... | obtain ⟨d, hd, rfl⟩ := exists_pos_add_of_lt' hcd
rw [mul_add, add_right_comm, mul_add, ← add_assoc]
gcongr
exact hd | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | {
"line": 865,
"column": 4
} | {
"line": 865,
"column": 74
} | [
{
"pp": "G₀ : Type u_3\ninst✝³ : GroupWithZero G₀\ninst✝² : PartialOrder G₀\ninst✝¹ : PosMulReflectLT G₀\ninst✝ : MulPosMono G₀\na : G₀\nha : 0 < a\nb c : G₀\nh : (fun x y ↦ y * ↑x) ⟨a, ha⟩ b ≤ (fun x y ↦ y * ↑x) ⟨a, ha⟩ c\n⊢ b ≤ c",
"usedConstants": [
"Iff.mpr",
"GroupWithZero.toMonoidWithZero"... | simpa [ha.ne'] using mul_le_mul_of_nonneg_right h (inv_nonneg.2 ha.le) | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Order.Hom.Basic | {
"line": 1176,
"column": 2
} | {
"line": 1176,
"column": 10
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝¹ : LE α\ninst✝ : PartialOrder β\nf : α ≃o β\nx : α\ny : β\nhx : ∀ (x' : α), x ≤ x'\nhy : ∀ (y' : β), y ≤ y'\n⊢ x ≤ f.symm y",
"usedConstants": [
"PartialOrder.toPreorder",
"Preorder.toLE",
"OrderIso",
"OrderIso.symm",
"instFunLikeOrder... | apply hx | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.Order.Group.Abs | {
"line": 37,
"column": 8
} | {
"line": 37,
"column": 26
} | [
{
"pp": "case inr\nG : Type u_1\ninst✝² : CommGroup G\ninst✝¹ : LinearOrder G\ninst✝ : IsOrderedMonoid G\nn : ℕ\na : G\nha : 1 ≤ a\n⊢ |a ^ n|ₘ = |a|ₘ ^ n",
"usedConstants": [
"Eq.mpr",
"congrArg",
"mabs_of_one_le",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
... | mabs_of_one_le ha, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Group.Unbundled.Abs | {
"line": 101,
"column": 7
} | {
"line": 101,
"column": 25
} | [
{
"pp": "α : Type u_1\ninst✝² : Lattice α\ninst✝¹ : Group α\na b : α\ninst✝ : MulLeftMono α\nha : 1 ≤ a\nhab : a ≤ b\n⊢ |a|ₘ ≤ |b|ₘ",
"usedConstants": [
"Eq.mpr",
"congrArg",
"mabs_of_one_le",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
... | mabs_of_one_le ha, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Group.Abs | {
"line": 60,
"column": 2
} | {
"line": 60,
"column": 36
} | [
{
"pp": "case inl\nG : Type u_1\ninst✝² : CommGroup G\ninst✝¹ : LinearOrder G\ninst✝ : IsOrderedMonoid G\na b : G\nab : a ≤ b\n⊢ |a * b|ₘ = |a|ₘ * |b|ₘ ↔ 1 ≤ a ∧ 1 ≤ b ∨ a ≤ 1 ∧ b ≤ 1",
"usedConstants": [
"_private.Mathlib.Algebra.Order.Group.Abs.0.mabs_mul_eq_mul_mabs_le"
]
},
{
"pp": "ca... | · exact mabs_mul_eq_mul_mabs_le ab | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Order.Group.Abs | {
"line": 216,
"column": 26
} | {
"line": 216,
"column": 65
} | [
{
"pp": "G : Type u_1\ninst✝² : CommGroup G\ninst✝¹ : LinearOrder G\ninst✝ : IsOrderedMonoid G\na b : G\n⊢ a = b → |a / b|ₘ ≤ 1",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"le_refl",
"instHDiv",
"mabs_one",
"InvOneClass.toOne",
"DivisionCommMonoid.toDivisionMonoi... | by rintro rfl; rw [div_self', mabs_one] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Ring.Int.Parity | {
"line": 121,
"column": 2
} | {
"line": 121,
"column": 31
} | [
{
"pp": "n : ℕ\n⊢ IsSquare ↑n ↔ IsSquare n",
"usedConstants": [
"instMulNat",
"Int",
"Nat.cast",
"Int.instMul",
"Nat",
"Iff.intro",
"IsSquare",
"instNatCastInt"
]
}
] | constructor <;> rintro ⟨x, h⟩ | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.Order.Ring.Int | {
"line": 76,
"column": 2
} | {
"line": 76,
"column": 56
} | [
{
"pp": "case succ.succ\nn p q : ℕ\ndvd : (p + 1).gcd (q + 1) ∣ n\nle : (p + 1).pred * (q + 1).pred ≤ n\n⊢ ∃ a b, a * (p + 1) + b * (q + 1) = n",
"usedConstants": [
"Nat.gcd",
"Int.gcd",
"Dvd.dvd",
"congrArg",
"Eq.mp",
"instOfNatNat",
"Int",
"Nat.cast",
... | rw [← Int.gcd_natCast_natCast, Int.gcd_dvd_iff] at dvd | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.AddGroupWithTop | {
"line": 122,
"column": 79
} | {
"line": 123,
"column": 49
} | [
{
"pp": "α : Type u_2\ninst✝ : LinearOrderedAddCommGroupWithTop α\na : α\nha : a ≠ ⊤\nb : α\n⊢ -a + (a + b) = b",
"usedConstants": [
"AddMonoid.toAddSemigroup",
"LinearOrderedAddCommGroupWithTop.neg_add_cancel_of_ne_top",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddZeroClass.to... | by
simp [← add_assoc, neg_add_cancel_of_ne_top ha] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.AddGroupWithTop | {
"line": 167,
"column": 21
} | {
"line": 173,
"column": 89
} | [
{
"pp": "G : Type u_1\nα : Type u_2\ninst✝ : LinearOrderedAddCommGroupWithTop α\na✝ b✝ c a b : α\n⊢ -(a + b) = -b + -a",
"usedConstants": [
"False",
"LinearOrderedAddCommGroupWithTop.add_eq_top._simp_1",
"eq_false",
"AddMonoid.toAddSemigroup",
"add_top",
"LinearOrderedAdd... | by
obtain rfl | ha := eq_or_ne a ⊤
· simp
obtain rfl | hb := eq_or_ne b ⊤
· simp
· exact left_neg_eq_right_neg (a := a + b) (by simp [neg_add_cancel_of_ne_top, *])
(by simp [add_assoc, add_neg_cancel_of_ne_top, add_neg_cancel_left_of_ne_top, *]) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | {
"line": 111,
"column": 38
} | {
"line": 111,
"column": 48
} | [
{
"pp": "α : Type u\ninst✝¹ : Add α\nx y : WithTop α\ninst✝ : LT α\n⊢ x + y ≠ ⊤ ↔ x ≠ ⊤ ∧ y ≠ ⊤",
"usedConstants": [
"congrArg",
"Ne",
"iff_self",
"instHAdd",
"And",
"Iff",
"WithTop.top",
"HAdd.hAdd",
"True",
"of_eq_true",
"congrFun'",
... | add_ne_top | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Order.Sub.Unbundled.Basic | {
"line": 106,
"column": 14
} | {
"line": 106,
"column": 53
} | [
{
"pp": "α : Type u_1\ninst✝⁵ : AddCommSemigroup α\ninst✝⁴ : PartialOrder α\ninst✝³ : ExistsAddOfLE α\ninst✝² : AddLeftMono α\ninst✝¹ : Sub α\ninst✝ : OrderedSub α\na b : α\nhb : AddLECancellable b\nhba : b ≤ a\nh : a < b + (a - b)\n⊢ False",
"usedConstants": [
"PartialOrder.toPreorder",
"HSub.h... | exact h.ne' (add_tsub_cancel_of_le hba) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.Directed | {
"line": 117,
"column": 2
} | {
"line": 117,
"column": 54
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nι : Sort u_3\ninst✝¹ : Preorder α\ninst✝ : OrderBot α\ne : ι → β\nf : ι → α\nhf : Directed (fun x1 x2 ↦ x1 ≤ x2) f\nhe : Injective e\na b : β\n⊢ ∃ z, (fun x1 x2 ↦ x1 ≤ x2) (extend e f ⊥ a) (extend e f ⊥ z) ∧ (fun x1 x2 ↦ x1 ≤ x2) (extend e f ⊥ b) (extend e f ⊥ z)",
"used... | rcases (em (∃ i, e i = a)).symm with (ha | ⟨i, rfl⟩) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Algebra.Ring.Invertible | {
"line": 139,
"column": 2
} | {
"line": 145,
"column": 35
} | [
{
"pp": "R : Type u_1\ninst✝ : Ring R\na b : R\nh : IsUnit a ↔ IsUnit b\n⊢ a⁻¹ʳ - b⁻¹ʳ = a⁻¹ʳ * (b - a) * b⁻¹ʳ",
"usedConstants": [
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"False",
"HMul.hMul",
"eq_false",
"MulZeroClass.toMul",
"sub_self",
"Monoid.toMulOn... | by_cases ha : IsUnit a
· have hb := h.mp ha
obtain ⟨ia⟩ := ha.nonempty_invertible
obtain ⟨ib⟩ := hb.nonempty_invertible
simp_rw [inverse_invertible, invOf_sub_invOf]
· have hb := h.not.mp ha
simp [inverse_non_unit, ha, hb] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Ring.Invertible | {
"line": 139,
"column": 2
} | {
"line": 145,
"column": 35
} | [
{
"pp": "R : Type u_1\ninst✝ : Ring R\na b : R\nh : IsUnit a ↔ IsUnit b\n⊢ a⁻¹ʳ - b⁻¹ʳ = a⁻¹ʳ * (b - a) * b⁻¹ʳ",
"usedConstants": [
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"False",
"HMul.hMul",
"eq_false",
"MulZeroClass.toMul",
"sub_self",
"Monoid.toMulOn... | by_cases ha : IsUnit a
· have hb := h.mp ha
obtain ⟨ia⟩ := ha.nonempty_invertible
obtain ⟨ib⟩ := hb.nonempty_invertible
simp_rw [inverse_invertible, invOf_sub_invOf]
· have hb := h.not.mp ha
simp [inverse_non_unit, ha, hb] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Ring.Basic | {
"line": 171,
"column": 14
} | {
"line": 171,
"column": 24
} | [
{
"pp": "R : Type u_3\ninst✝³ : Semiring R\ninst✝² : LinearOrder R\ninst✝¹ : IsStrictOrderedRing R\na : R\ninst✝ : ExistsAddOfLE R\nhn : Odd 0\n⊢ False",
"usedConstants": [
"False",
"False.elim",
"Odd",
"Eq.mp",
"instOfNatNat",
"Nat.not_odd_zero._simp_1",
"Nat",
... | simp at hn | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Group.Int.Units | {
"line": 56,
"column": 2
} | {
"line": 57,
"column": 70
} | [
{
"pp": "u v : ℤ\nh : u * v = 1\nh' : v * u = 1\n⊢ u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1",
"usedConstants": [
"Iff.mpr",
"Int.ctorIdx",
"HMul.hMul",
"False.elim",
"noConfusion_of_Nat",
"Int.instDecidableEq",
"Int.instNegInt",
"Int",
"Or.casesOn",
"Int.in... | obtain rfl | rfl := eq_one_or_neg_one_of_mul_eq_one h <;>
obtain rfl | rfl := eq_one_or_neg_one_of_mul_eq_one h' <;> tauto | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Order.WellFounded | {
"line": 155,
"column": 2
} | {
"line": 155,
"column": 31
} | [
{
"pp": "case refine_3\nα : Type u_1\nr : α → α → Prop\nh : ∀ (s : Set α), s.Nonempty → ∃ m, m ∈ s ∧ ∀ (x : α), x ∈ s → ¬r x m ∧ (m = x ∨ r m x)\na b : α\n⊢ ¬r a b → ¬r b a → a = b",
"usedConstants": [
"_private.Mathlib.Order.WellFounded.0.WellFounded.isWellOrder_iff_exists_not_lt_and_eq_or_gt._proof_... | · grind [h {a, b} <| by simp] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.Interval.Set.Basic | {
"line": 58,
"column": 72
} | {
"line": 58,
"column": 85
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Preorder α\na a₁ a₂ b b₁ b₂ c x : α\ninst✝ : Decidable (x < b)\n⊢ Decidable (x ∈ Iio b)",
"usedConstants": []
}
] | by assumption | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Interval.Set.Basic | {
"line": 61,
"column": 72
} | {
"line": 61,
"column": 85
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Preorder α\na a₁ a₂ b b₁ b₂ c x : α\ninst✝ : Decidable (x ≤ b)\n⊢ Decidable (x ∈ Iic b)",
"usedConstants": []
}
] | by assumption | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Interval.Set.Basic | {
"line": 484,
"column": 4
} | {
"line": 484,
"column": 77
} | [
{
"pp": "case refine_1\nα : Type u_1\ninst✝ : PartialOrder α\na b c : α\nh : Icc a b = {c}\n⊢ a = c ∧ b = c",
"usedConstants": [
"Set.singleton_nonempty",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Eq.subst",
"Set.nonempty_Icc",
"Set.instSingletonSet",
"LE.le",
... | have hab : a ≤ b := nonempty_Icc.1 (h.symm.subst <| singleton_nonempty c) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Order.Bounds.Basic | {
"line": 352,
"column": 71
} | {
"line": 354,
"column": 66
} | [
{
"pp": "ι : Sort u_4\nα : Type u_5\ninst✝ : SemilatticeSup α\nf g : ι → α\nh : BddAbove (range fun x ↦ f x ⊔ g x)\n⊢ BddAbove (range g)",
"usedConstants": [
"PartialOrder.toPreorder",
"_private.Mathlib.Order.Bounds.Basic.0.bbdAbove_range_right_of_sup.match_1_1",
"_private.Mathlib.Order.Bo... | by
have ⟨b, hb⟩ := h
exact ⟨b, fun a ⟨i, ha⟩ ↦ ha ▸ le_sup_right.trans (hb ⟨i, rfl⟩)⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.GroupWithZero.Unbundled.OrderIso | {
"line": 71,
"column": 2
} | {
"line": 71,
"column": 46
} | [
{
"pp": "case inr\nG₀ : Type u_1\ninst✝² : GroupWithZero G₀\ninst✝¹ : SemilatticeInf G₀\ninst✝ : PosMulReflectLT G₀\nc : G₀\nhc✝ : 0 ≤ c\na b : G₀\nhc : 0 < c\n⊢ c * (a ⊓ b) = c * a ⊓ c * b",
"usedConstants": [
"OrderIso.map_inf",
"SemilatticeInf.toPartialOrder",
"OrderIso.mulLeft₀"
]
... | · exact (OrderIso.mulLeft₀ c hc).map_inf a b | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Tactic.Abel | {
"line": 235,
"column": 2
} | {
"line": 235,
"column": 52
} | [
{
"pp": "α : Type u_1\ninst✝ : AddCommGroup α\nn : ℤ\nx a : α\nn' : ℤ\na' : α\nh₁ : -n = n'\nh₂ : -a = a'\n⊢ -termg n x a = termg n' x a'",
"usedConstants": [
"neg_add_rev",
"Eq.mpr",
"NegZeroClass.toNeg",
"instHSMul",
"neg_zsmul",
"congrArg",
"AddCommGroup.toAddCom... | simpa [h₂.symm, h₁.symm, termg] using add_comm _ _ | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Tactic.Abel | {
"line": 235,
"column": 2
} | {
"line": 235,
"column": 52
} | [
{
"pp": "α : Type u_1\ninst✝ : AddCommGroup α\nn : ℤ\nx a : α\nn' : ℤ\na' : α\nh₁ : -n = n'\nh₂ : -a = a'\n⊢ -termg n x a = termg n' x a'",
"usedConstants": [
"neg_add_rev",
"Eq.mpr",
"NegZeroClass.toNeg",
"instHSMul",
"neg_zsmul",
"congrArg",
"AddCommGroup.toAddCom... | simpa [h₂.symm, h₁.symm, termg] using add_comm _ _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.Abel | {
"line": 235,
"column": 2
} | {
"line": 235,
"column": 52
} | [
{
"pp": "α : Type u_1\ninst✝ : AddCommGroup α\nn : ℤ\nx a : α\nn' : ℤ\na' : α\nh₁ : -n = n'\nh₂ : -a = a'\n⊢ -termg n x a = termg n' x a'",
"usedConstants": [
"neg_add_rev",
"Eq.mpr",
"NegZeroClass.toNeg",
"instHSMul",
"neg_zsmul",
"congrArg",
"AddCommGroup.toAddCom... | simpa [h₂.symm, h₁.symm, termg] using add_comm _ _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Field.Basic | {
"line": 144,
"column": 2
} | {
"line": 145,
"column": 41
} | [
{
"pp": "α : Type u_2\ninst✝² : Semifield α\ninst✝¹ : PartialOrder α\ninst✝ : IsStrictOrderedRing α\na : α\n⊢ a / 3 + a / 3 + a / 3 = a",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"instHDiv",
"HMul.hMul",
"GroupWithZero.toDivI... | rw [← add_div, ← add_div, ← two_mul, ← add_one_mul 2 a, two_add_one_eq_three,
mul_div_cancel_left₀ a three_ne_zero] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Field.Basic | {
"line": 144,
"column": 2
} | {
"line": 145,
"column": 41
} | [
{
"pp": "α : Type u_2\ninst✝² : Semifield α\ninst✝¹ : PartialOrder α\ninst✝ : IsStrictOrderedRing α\na : α\n⊢ a / 3 + a / 3 + a / 3 = a",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"instHDiv",
"HMul.hMul",
"GroupWithZero.toDivI... | rw [← add_div, ← add_div, ← two_mul, ← add_one_mul 2 a, two_add_one_eq_three,
mul_div_cancel_left₀ a three_ne_zero] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Field.Basic | {
"line": 144,
"column": 2
} | {
"line": 145,
"column": 41
} | [
{
"pp": "α : Type u_2\ninst✝² : Semifield α\ninst✝¹ : PartialOrder α\ninst✝ : IsStrictOrderedRing α\na : α\n⊢ a / 3 + a / 3 + a / 3 = a",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"instHDiv",
"HMul.hMul",
"GroupWithZero.toDivI... | rw [← add_div, ← add_div, ← two_mul, ← add_one_mul 2 a, two_add_one_eq_three,
mul_div_cancel_left₀ a three_ne_zero] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Field.Basic | {
"line": 589,
"column": 4
} | {
"line": 589,
"column": 22
} | [
{
"pp": "case inr.inl\nα : Type u_2\ninst✝² : Field α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na : α\n⊢ 1 < a / 0 ↔ 0 < 0 ∧ 0 < a ∨ 0 < 0 ∧ a < 0",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"Preorder.toLT",
"instHDiv",
"iff_false",
"cong... | simp [zero_le_one] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Order.Field.Basic | {
"line": 589,
"column": 4
} | {
"line": 589,
"column": 22
} | [
{
"pp": "case inr.inl\nα : Type u_2\ninst✝² : Field α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na : α\n⊢ 1 < a / 0 ↔ 0 < 0 ∧ 0 < a ∨ 0 < 0 ∧ a < 0",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"Preorder.toLT",
"instHDiv",
"iff_false",
"cong... | simp [zero_le_one] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Field.Basic | {
"line": 589,
"column": 4
} | {
"line": 589,
"column": 22
} | [
{
"pp": "case inr.inl\nα : Type u_2\ninst✝² : Field α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na : α\n⊢ 1 < a / 0 ↔ 0 < 0 ∧ 0 < a ∨ 0 < 0 ∧ a < 0",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"Preorder.toLT",
"instHDiv",
"iff_false",
"cong... | simp [zero_le_one] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Field.Basic | {
"line": 607,
"column": 4
} | {
"line": 607,
"column": 22
} | [
{
"pp": "case inr.inl\nα : Type u_2\ninst✝² : Field α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na : α\n⊢ a / 0 ≤ 1 ↔ 0 < 0 ∧ a ≤ 0 ∨ 0 = 0 ∨ 0 < 0 ∧ 0 ≤ a",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"Preorder.toLT",
"instHDiv",
"congrArg",
... | simp [zero_le_one] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Order.Field.Basic | {
"line": 607,
"column": 4
} | {
"line": 607,
"column": 22
} | [
{
"pp": "case inr.inl\nα : Type u_2\ninst✝² : Field α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na : α\n⊢ a / 0 ≤ 1 ↔ 0 < 0 ∧ a ≤ 0 ∨ 0 = 0 ∨ 0 < 0 ∧ 0 ≤ a",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"Preorder.toLT",
"instHDiv",
"congrArg",
... | simp [zero_le_one] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Field.Basic | {
"line": 607,
"column": 4
} | {
"line": 607,
"column": 22
} | [
{
"pp": "case inr.inl\nα : Type u_2\ninst✝² : Field α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na : α\n⊢ a / 0 ≤ 1 ↔ 0 < 0 ∧ a ≤ 0 ∨ 0 = 0 ∨ 0 < 0 ∧ 0 ≤ a",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"Preorder.toLT",
"instHDiv",
"congrArg",
... | simp [zero_le_one] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Basic | {
"line": 813,
"column": 33
} | {
"line": 813,
"column": 51
} | [
{
"pp": "α : Type u\nβ : Type v\nf : α → β → β\nb : β\nhf : ∀ (a : α), f a b = b\na : α\nl : List α\n⊢ f a (foldr f b l) = b",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"List.foldr",
"Eq"
]
}
] | foldr_fixed' hf l, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Basic | {
"line": 898,
"column": 17
} | {
"line": 898,
"column": 26
} | [
{
"pp": "case cons.none\nα : Type u\nβ : Type v\nf : α → Option β\na : α\nl : List α\nih : filterMap f l = flatMap (fun a ↦ (f a).toList) l\n⊢ (match none with\n | none => filterMap f l\n | some b => b :: filterMap f l) =\n none.toList ++ flatMap (fun a ↦ (f a).toList) l",
"usedConstants": [
... | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Basic | {
"line": 898,
"column": 17
} | {
"line": 898,
"column": 26
} | [
{
"pp": "case cons.some\nα : Type u\nβ : Type v\nf : α → Option β\na : α\nl : List α\nih : filterMap f l = flatMap (fun a ↦ (f a).toList) l\nval✝ : β\n⊢ (match some val✝ with\n | none => filterMap f l\n | some b => b :: filterMap f l) =\n (some val✝).toList ++ flatMap (fun a ↦ (f a).toList) l",
"us... | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Basic | {
"line": 952,
"column": 2
} | {
"line": 952,
"column": 24
} | [
{
"pp": "α : Type u\nl : List α\np q : α → Bool\nh : ∀ (a : α), p a = true → q a = true\n⊢ filter p l <+ filter q l",
"usedConstants": [
"_private.Mathlib.Data.List.Basic.0.List.monotone_filter_right._proof_1_2",
"List.rec",
"List",
"List.filter",
"List.Sublist",
"_privat... | induction l with grind | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.List.Basic | {
"line": 952,
"column": 2
} | {
"line": 952,
"column": 24
} | [
{
"pp": "α : Type u\nl : List α\np q : α → Bool\nh : ∀ (a : α), p a = true → q a = true\n⊢ filter p l <+ filter q l",
"usedConstants": [
"_private.Mathlib.Data.List.Basic.0.List.monotone_filter_right._proof_1_2",
"List.rec",
"List",
"List.filter",
"List.Sublist",
"_privat... | induction l with grind | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Basic | {
"line": 952,
"column": 2
} | {
"line": 952,
"column": 24
} | [
{
"pp": "α : Type u\nl : List α\np q : α → Bool\nh : ∀ (a : α), p a = true → q a = true\n⊢ filter p l <+ filter q l",
"usedConstants": [
"_private.Mathlib.Data.List.Basic.0.List.monotone_filter_right._proof_1_2",
"List.rec",
"List",
"List.filter",
"List.Sublist",
"_privat... | induction l with grind | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Basic | {
"line": 978,
"column": 36
} | {
"line": 978,
"column": 71
} | [
{
"pp": "α : Type u\nl : List α\n⊢ filter (fun x ↦ true) l = l",
"usedConstants": [
"congrArg",
"List.rec",
"List.cons",
"Bool.true",
"List",
"List.filter",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"Eq",
"Eq.trans",
"List.nil... | by induction l <;> simp [*, filter] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Basic | {
"line": 982,
"column": 38
} | {
"line": 982,
"column": 73
} | [
{
"pp": "α : Type u\nl : List α\n⊢ filter (fun x ↦ false) l = []",
"usedConstants": [
"congrArg",
"List.rec",
"List.cons",
"List",
"List.filter",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"Bool.false",
"Eq",
"Eq.trans",
"List.... | by induction l <;> simp [*, filter] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Rat.Cast.Defs | {
"line": 169,
"column": 59
} | {
"line": 169,
"column": 74
} | [
{
"pp": "α : Type u_3\ninst✝ : DivisionRing α\nq r : ℚ\nhq : ↑q.den ≠ 0\nhr : ↑r.den ≠ 0\n⊢ ↑(q.num * ↑r.den + r.num * ↑q.den) / ↑(q.den * r.den) = ↑q.num / ↑q.den + ↑r.num / ↑r.den",
"usedConstants": [
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Int.cast",
"Eq.mpr",
... | mul_comm r.num, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Tactic.Ring.Common | {
"line": 896,
"column": 2
} | {
"line": 896,
"column": 44
} | [
{
"pp": "R : Type u_1\ninst✝ : CommSemiring R\na₂ c₂ : R\nea₁ b c₁ : ℕ\nxa₁ : R\nx✝¹ : ea₁ * b = c₁\nx✝ : a₂ ^ b = c₂\n⊢ (xa₁ ^ ea₁ * a₂) ^ b = xa₁ ^ c₁ * c₂",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"MulOne.toMul",
"... | subst_vars; simp [_root_.mul_pow, pow_mul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.Ring.Common | {
"line": 896,
"column": 2
} | {
"line": 896,
"column": 44
} | [
{
"pp": "R : Type u_1\ninst✝ : CommSemiring R\na₂ c₂ : R\nea₁ b c₁ : ℕ\nxa₁ : R\nx✝¹ : ea₁ * b = c₁\nx✝ : a₂ ^ b = c₂\n⊢ (xa₁ ^ ea₁ * a₂) ^ b = xa₁ ^ c₁ * c₂",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"MulOne.toMul",
"... | subst_vars; simp [_root_.mul_pow, pow_mul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Tactic.Ring.Common | {
"line": 1224,
"column": 17
} | {
"line": 1226,
"column": 10
} | [
{
"pp": "R : Type u_2\nα : Type u_3\ninst✝¹ : CommSemiring α\ninst✝ : SMul R α\nr : R\na b t c : α\nx✝² : a = b\nx✝¹ : ∀ (x : α), r • x = t * x\nx✝ : t * b = c\n⊢ r • a = c",
"usedConstants": [
"instHSMul",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"instDistribOfSemir... | by
subst_vars
simp [*] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Ring.Canonical | {
"line": 129,
"column": 38
} | {
"line": 129,
"column": 47
} | [
{
"pp": "R : Type u\ninst✝⁶ : NonAssocSemiring R\ninst✝⁵ : PartialOrder R\ninst✝⁴ : CanonicallyOrderedAdd R\ninst✝³ : Sub R\ninst✝² : OrderedSub R\ninst✝¹ : Std.Total fun x1 x2 ↦ x1 ≤ x2\ninst✝ : AddLeftReflectLE R\na b : R\n⊢ a * (b - 1) = a * b - a",
"usedConstants": [
"Eq.mpr",
"NonAssocSemir... | mul_tsub, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Canonical | {
"line": 143,
"column": 6
} | {
"line": 143,
"column": 15
} | [
{
"pp": "R : Type u\ninst✝⁶ : CommSemiring R\ninst✝⁵ : PartialOrder R\ninst✝⁴ : CanonicallyOrderedAdd R\ninst✝³ : Sub R\ninst✝² : OrderedSub R\ninst✝¹ : Std.Total fun x1 x2 ↦ x1 ≤ x2\ninst✝ : AddLeftReflectLE R\na b : R\n⊢ a * a - b * b = (a + b) * (a - b)",
"usedConstants": [
"Eq.mpr",
"HMul.hM... | mul_tsub, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.ConditionallyCompleteLattice.Basic | {
"line": 395,
"column": 2
} | {
"line": 395,
"column": 22
} | [
{
"pp": "α : Type u_1\ninst✝ : ConditionallyCompleteLinearOrder α\ns : Set α\nb : α\nhs : s.Nonempty\nhb : ∀ a ∈ s, a ≤ b\n⊢ sSup s ≤ b",
"usedConstants": [
"ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice",
"csSup_le"
]
}
] | exact csSup_le hs hb | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.ConditionallyCompleteLattice.Basic | {
"line": 755,
"column": 27
} | {
"line": 758,
"column": 59
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Preorder α\ninst✝ : ConditionallyCompleteLattice β\nf : α → β\nh_mono : Monotone f\ns : Set α\nhs : s.Nonempty\nB : α\nhB : B ∈ lowerBounds s\n⊢ f B ≤ sInf (f '' s)",
"usedConstants": [
"PartialOrder.toPreorder",
"Monotone",
"Preorder.toLE",
... | by
let f' : αᵒᵈ → βᵒᵈ := f
exact csSup_image_le (α := αᵒᵈ) (β := βᵒᵈ)
(show Monotone f' from fun x y hxy => h_mono hxy) hs hB | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.CompleteBooleanAlgebra | {
"line": 921,
"column": 2
} | {
"line": 921,
"column": 53
} | [
{
"pp": "α : Type u\nβ : Type v\nι : Sort w\nκ : ι → Sort w'\ne : α ≃ β\ninst✝ : CompleteDistribLattice β\ncompleteLattice : CompleteLattice α := e.completeLattice\nbiheytingAlgebra : BiheytingAlgebra α := e.biheytingAlgebra\n⊢ CompleteDistribLattice α",
"usedConstants": [
"BiheytingAlgebra.toSDiff",
... | apply e.injective.completeDistribLattice <;> intros | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Tactic.NormNum.Abs | {
"line": 39,
"column": 2
} | {
"line": 43,
"column": 57
} | [
{
"pp": "α : Type u_1\ninst✝² : DivisionRing α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na : α\nnum den : ℕ\nra : IsNNRat a num den\n⊢ IsNNRat |a| num den",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"mul_nonneg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"_p... | obtain ⟨ha1, rfl⟩ := ra
refine ⟨ha1, abs_of_nonneg ?_⟩
apply mul_nonneg
· exact Nat.cast_nonneg' num
· simp only [invOf_eq_inv, inv_nonneg, Nat.cast_nonneg] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.NormNum.Abs | {
"line": 39,
"column": 2
} | {
"line": 43,
"column": 57
} | [
{
"pp": "α : Type u_1\ninst✝² : DivisionRing α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na : α\nnum den : ℕ\nra : IsNNRat a num den\n⊢ IsNNRat |a| num den",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"mul_nonneg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"_p... | obtain ⟨ha1, rfl⟩ := ra
refine ⟨ha1, abs_of_nonneg ?_⟩
apply mul_nonneg
· exact Nat.cast_nonneg' num
· simp only [invOf_eq_inv, inv_nonneg, Nat.cast_nonneg] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Rat.Cast.Order | {
"line": 70,
"column": 26
} | {
"line": 70,
"column": 38
} | [
{
"pp": "K : Type u_5\ninst✝² : Field K\ninst✝¹ : LinearOrder K\ninst✝ : IsStrictOrderedRing K\nm : ℚ\nn : ℤ\n⊢ ↑m ≤ ↑n ↔ ↑m ≤ ↑↑n",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Rat.cast_intCast",
"DivisionRing.toRatCast",
"congrArg",
"Rat",
"PartialOrder.toPreorder",
... | cast_intCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Rat.Cast.Order | {
"line": 74,
"column": 26
} | {
"line": 74,
"column": 38
} | [
{
"pp": "K : Type u_5\ninst✝² : Field K\ninst✝¹ : LinearOrder K\ninst✝ : IsStrictOrderedRing K\nm : ℤ\nn : ℚ\n⊢ ↑m ≤ ↑n ↔ ↑↑m ≤ ↑n",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Rat.cast_intCast",
"DivisionRing.toRatCast",
"congrArg",
"Rat",
"PartialOrder.toPreorder",
... | cast_intCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Rat.Cast.Order | {
"line": 86,
"column": 26
} | {
"line": 86,
"column": 38
} | [
{
"pp": "K : Type u_5\ninst✝² : Field K\ninst✝¹ : LinearOrder K\ninst✝ : IsStrictOrderedRing K\nm : ℚ\nn : ℤ\n⊢ ↑m < ↑n ↔ ↑m < ↑↑n",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Rat.cast_intCast",
"Preorder.toLT",
"DivisionRing.toRatCast",
"congrArg",
"Rat",
"Par... | cast_intCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Rat.Cast.Order | {
"line": 90,
"column": 26
} | {
"line": 90,
"column": 38
} | [
{
"pp": "K : Type u_5\ninst✝² : Field K\ninst✝¹ : LinearOrder K\ninst✝ : IsStrictOrderedRing K\nm : ℤ\nn : ℚ\n⊢ ↑m < ↑n ↔ ↑↑m < ↑n",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Rat.cast_intCast",
"Preorder.toLT",
"DivisionRing.toRatCast",
"congrArg",
"Rat",
"Par... | cast_intCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Int.Cast.Field | {
"line": 42,
"column": 33
} | {
"line": 42,
"column": 43
} | [
{
"pp": "α : Type u_1\ninst✝ : DivisionRing α\nk : ℤ\nhn : ↑0 ≠ 0\n⊢ False",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast",
"False",
"AddGroupWithOne.toAddGroup",
"congrArg",
"Int.cast_zero",
"False.elim",
"DivisionRing.toDivisionSemiring",
... | simp at hn | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Order.Group.PosPart | {
"line": 111,
"column": 75
} | {
"line": 112,
"column": 29
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Lattice α\ninst✝ : Group α\na : α\n⊢ a⁻¹⁻ᵐ = a⁺ᵐ",
"usedConstants": [
"Lattice.toSemilatticeSup",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"instLeOnePart",
"congrArg",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOne... | by
simp [oneLePart, leOnePart] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Group.PosPart | {
"line": 213,
"column": 63
} | {
"line": 214,
"column": 81
} | [
{
"pp": "α : Type u_1\ninst✝² : Lattice α\ninst✝¹ : CommGroup α\ninst✝ : MulLeftMono α\na : α\n⊢ |a|ₘ / a = a⁻ᵐ ^ 2",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"CommMonoid.toCommSemigroup",
"instLeOnePart",
"Monoid.toMulOneClass",
"congrArg",
"Part... | by
rw [sq, ← mul_div_div_cancel, oneLePart_mul_leOnePart, oneLePart_div_leOnePart] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 375,
"column": 21
} | {
"line": 375,
"column": 74
} | [
{
"pp": "n : ℕ\nx✝ : 0 ≤ n\n⊢ (n - 0)! * n.descFactorial 0 = n !",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Nat.mul_one",
"congrArg",
"HSub.hSub",
"id",
"instSubNat",
"instMulNat",
"instOfNatNat",
"instHSub",
"Nat.factorial",
"Nat",
... | by rw [descFactorial_zero, Nat.mul_one, Nat.sub_zero] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Tactic.NormNum.Ineq | {
"line": 88,
"column": 4
} | {
"line": 88,
"column": 43
} | [
{
"pp": "α : Type u_1\ninst✝² : Semiring α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\nnum✝¹ num✝ da db : ℕ\ninv✝¹ : Invertible ↑da\ninv✝ : Invertible ↑db\nh✝¹ : decide (num✝¹.mul db ≤ num✝.mul da) = true\nh✝ : ↑(num✝¹.mul db) ≤ ↑(num✝.mul da)\nha : 0 ≤ ⅟↑da\nhb : 0 ≤ ⅟↑db\nh : ⅟↑db * (↑(num✝¹.mul d... | rw [← mul_assoc, Nat.commute_cast] at h | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Tactic.NormNum.Ineq | {
"line": 100,
"column": 4
} | {
"line": 100,
"column": 43
} | [
{
"pp": "α : Type u_1\ninst✝³ : Semiring α\ninst✝² : LinearOrder α\ninst✝¹ : IsStrictOrderedRing α\ninst✝ : Nontrivial α\nnum✝¹ num✝ da db : ℕ\ninv✝¹ : Invertible ↑da\ninv✝ : Invertible ↑db\nh✝¹ : decide (num✝¹ * db < num✝ * da) = true\nh✝ : ↑(num✝¹ * db) < ↑(num✝ * da)\nha : 0 < ⅟↑da\nhb : 0 < ⅟↑db\nh : ⅟↑db *... | rw [← mul_assoc, Nat.commute_cast] at h | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 501,
"column": 2
} | {
"line": 501,
"column": 9
} | [
{
"pp": "⊢ ascFactorial = ascFactorialBinary",
"usedConstants": [
"Nat.ascFactorial",
"funext",
"Nat.ascFactorialBinary",
"Nat"
]
}
] | ext n k | _private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.evalExt | Lean.Elab.Tactic.Ext.ext |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 526,
"column": 2
} | {
"line": 526,
"column": 9
} | [
{
"pp": "⊢ descFactorial = descFactorialBinary",
"usedConstants": [
"Nat.descFactorialBinary",
"funext",
"Nat",
"Nat.descFactorial"
]
}
] | ext n k | _private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.evalExt | Lean.Elab.Tactic.Ext.ext |
Mathlib.Data.PNat.Basic | {
"line": 247,
"column": 2
} | {
"line": 247,
"column": 24
} | [
{
"pp": "case pos\na b : ℕ+\nh : b < a\n⊢ ↑a - ↑b ≤ ↑a",
"usedConstants": [
"PNat.val",
"Nat.sub_le"
]
},
{
"pp": "case neg\na b : ℕ+\nh : ¬b < a\n⊢ 1 ≤ ↑a",
"usedConstants": []
}
] | · exact Nat.sub_le a b | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.PNat.Basic | {
"line": 297,
"column": 2
} | {
"line": 298,
"column": 23
} | [
{
"pp": "m k : ℕ+\n⊢ ↑(m.mod k) + m.div k * ↑k = ↑m",
"usedConstants": [
"PNat.val",
"Eq.mpr",
"HMul.hMul",
"CommSemiring.toNonUnitalCommSemiring",
"congrArg",
"PNat.div",
"PNat.mod_add_div",
"id",
"PNat.mod",
"CommMagma.toMul",
"instMulNat",... | rw [mul_comm]
exact mod_add_div _ _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PNat.Basic | {
"line": 297,
"column": 2
} | {
"line": 298,
"column": 23
} | [
{
"pp": "m k : ℕ+\n⊢ ↑(m.mod k) + m.div k * ↑k = ↑m",
"usedConstants": [
"PNat.val",
"Eq.mpr",
"HMul.hMul",
"CommSemiring.toNonUnitalCommSemiring",
"congrArg",
"PNat.div",
"PNat.mod_add_div",
"id",
"PNat.mod",
"CommMagma.toMul",
"instMulNat",... | rw [mul_comm]
exact mod_add_div _ _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Group.Basic | {
"line": 112,
"column": 2
} | {
"line": 116,
"column": 12
} | [
{
"pp": "case inr.inr\nα : Type u_1\ninst✝⁴ : CommGroup α\ninst✝³ : LinearOrder α\ninst✝² : IsOrderedMonoid α\ninst✝¹ : DenselyOrdered α\ninst✝ : Nontrivial α\nh : IsCyclic α\na : α\nha : Surjective fun x ↦ a ^ x\nhlt : 1 < a\n⊢ False",
"usedConstants": [
"zpow_lt_zpow_iff_right",
"Eq.mpr",
... | · rcases exists_between hlt with ⟨b, hb, hba⟩
rcases ha b with ⟨k, rfl⟩
suffices 0 < k ∧ k < 1 by lia
simp_rw [← zpow_lt_zpow_iff_right hlt]
simp_all | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Order.Archimedean.Basic | {
"line": 253,
"column": 2
} | {
"line": 253,
"column": 25
} | [
{
"pp": "K : Type u_4\ninst✝⁴ : Semifield K\ninst✝³ : LinearOrder K\ninst✝² : IsStrictOrderedRing K\ninst✝¹ : Archimedean K\nx y : K\ninst✝ : ExistsAddOfLE K\nhx : 0 < x\nhy : y < 1\n⊢ ∃ n, y ^ n < x",
"usedConstants": [
"Preorder.toLT",
"PartialOrder.toPreorder",
"Preorder.toLE",
"E... | by_cases! y_pos : y ≤ 0 | Mathlib.Tactic.ByCases._aux_Mathlib_Tactic_ByCases___macroRules_Mathlib_Tactic_ByCases_byCases!_1 | Mathlib.Tactic.ByCases.byCases! |
Mathlib.Algebra.Order.Archimedean.Basic | {
"line": 385,
"column": 4
} | {
"line": 385,
"column": 49
} | [
{
"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\n⊢ ∃ m, y ≤ (↑m * δ) ^ n",
"usedCon... | have ⟨m, hm⟩ := exists_nat_ge (y / δ + 1 / δ) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Multiset.AddSub | {
"line": 266,
"column": 34
} | {
"line": 267,
"column": 77
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\na b : α\nab : a ≠ b\ns : Multiset α\nl : List α\n⊢ count a (erase ⟦l⟧ b) = count a ⟦l⟧",
"usedConstants": [
"Eq.mpr",
"Multiset.coe_count",
"instLawfulBEq",
"congrArg",
"HEq.refl",
"Multiset.count",
"Eq.casesOn",
"... | by
convert! List.count_erase_of_ne ab (l := l) <;> rw [← coe_count] <;> simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Multiset.AddSub | {
"line": 299,
"column": 47
} | {
"line": 299,
"column": 56
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nt : Multiset α\na : α\ns : Multiset α\nih : 0 - s = 0\n⊢ 0 - a ::ₘ s = 0",
"usedConstants": [
"False",
"Multiset.notMem_zero._simp_1",
"congrArg",
"HSub.hSub",
"Membership.mem",
"Multiset",
"Multiset.cons",
"Multis... | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Multiset.AddSub | {
"line": 299,
"column": 47
} | {
"line": 299,
"column": 56
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nt : Multiset α\na : α\ns : Multiset α\nih : 0 - s = 0\n⊢ 0 - a ::ₘ s = 0",
"usedConstants": [
"False",
"Multiset.notMem_zero._simp_1",
"congrArg",
"HSub.hSub",
"Membership.mem",
"Multiset",
"Multiset.cons",
"Multis... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Multiset.AddSub | {
"line": 299,
"column": 47
} | {
"line": 299,
"column": 56
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nt : Multiset α\na : α\ns : Multiset α\nih : 0 - s = 0\n⊢ 0 - a ::ₘ s = 0",
"usedConstants": [
"False",
"Multiset.notMem_zero._simp_1",
"congrArg",
"HSub.hSub",
"Membership.mem",
"Multiset",
"Multiset.cons",
"Multis... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Replicate | {
"line": 126,
"column": 31
} | {
"line": 128,
"column": 64
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\na : α\ns : Multiset α\nn : ℕ\n_l : List α\n⊢ n ≤ count a (Quot.mk (⇑(isSetoid α)) _l) ↔ replicate n a ≤ Quot.mk (⇑(isSetoid α)) _l",
"usedConstants": [
"Eq.mpr",
"List.replicate",
"Multiset.coe_count",
"instLawfulBEq",
"congrArg",
... | by
simp only [quot_mk_to_coe'', coe_count]
exact replicate_sublist_iff.symm.trans replicate_le_coe.symm | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Multiset.ZeroCons | {
"line": 381,
"column": 2
} | {
"line": 381,
"column": 17
} | [
{
"pp": "α : Type u_1\ns t : Multiset α\na : α\nhs : ¬a ∈ s\n⊢ a ∈ t ∧ s ≤ t → a ::ₘ s ≤ t",
"usedConstants": [
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Multiset",
"LE.le",
"Multiset.instMembership",
"And",
"Multiset.instPartialOrder"
... | rintro ⟨h₁, h₂⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Data.List.Dedup | {
"line": 82,
"column": 17
} | {
"line": 82,
"column": 74
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Inhabited α\nl✝ : List α\na : α\nl : List α\n⊢ (a :: l).dedup.headI = if (a :: l).headI ∈ (a :: l).tail then (a :: l).tail.dedup.headI else (a :: l).headI",
"usedConstants": [
"False",
"eq_false",
"instLawfulBEq",
"congrArg",
... | by_cases ha : a ∈ l <;> simp [ha, List.dedup_cons_of_mem] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.List.Dedup | {
"line": 82,
"column": 17
} | {
"line": 82,
"column": 74
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Inhabited α\nl✝ : List α\na : α\nl : List α\n⊢ (a :: l).dedup.headI = if (a :: l).headI ∈ (a :: l).tail then (a :: l).tail.dedup.headI else (a :: l).headI",
"usedConstants": [
"False",
"eq_false",
"instLawfulBEq",
"congrArg",
... | by_cases ha : a ∈ l <;> simp [ha, List.dedup_cons_of_mem] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Dedup | {
"line": 82,
"column": 17
} | {
"line": 82,
"column": 74
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Inhabited α\nl✝ : List α\na : α\nl : List α\n⊢ (a :: l).dedup.headI = if (a :: l).headI ∈ (a :: l).tail then (a :: l).tail.dedup.headI else (a :: l).headI",
"usedConstants": [
"False",
"eq_false",
"instLawfulBEq",
"congrArg",
... | by_cases ha : a ∈ l <;> simp [ha, List.dedup_cons_of_mem] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Dedup | {
"line": 88,
"column": 17
} | {
"line": 88,
"column": 74
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Inhabited α\nl✝ : List α\na : α\nl : List α\n⊢ (a :: l).dedup.tail = if (a :: l).headI ∈ (a :: l).tail then (a :: l).tail.dedup.tail else (a :: l).tail.dedup",
"usedConstants": [
"False",
"eq_false",
"instLawfulBEq",
"congrArg",
... | by_cases ha : a ∈ l <;> simp [ha, List.dedup_cons_of_mem] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.List.Dedup | {
"line": 88,
"column": 17
} | {
"line": 88,
"column": 74
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Inhabited α\nl✝ : List α\na : α\nl : List α\n⊢ (a :: l).dedup.tail = if (a :: l).headI ∈ (a :: l).tail then (a :: l).tail.dedup.tail else (a :: l).tail.dedup",
"usedConstants": [
"False",
"eq_false",
"instLawfulBEq",
"congrArg",
... | by_cases ha : a ∈ l <;> simp [ha, List.dedup_cons_of_mem] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Dedup | {
"line": 88,
"column": 17
} | {
"line": 88,
"column": 74
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Inhabited α\nl✝ : List α\na : α\nl : List α\n⊢ (a :: l).dedup.tail = if (a :: l).headI ∈ (a :: l).tail then (a :: l).tail.dedup.tail else (a :: l).tail.dedup",
"usedConstants": [
"False",
"eq_false",
"instLawfulBEq",
"congrArg",
... | by_cases ha : a ∈ l <;> simp [ha, List.dedup_cons_of_mem] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Lattice | {
"line": 121,
"column": 2
} | {
"line": 121,
"column": 24
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nl : List α\n⊢ l ∩ [] = []",
"usedConstants": [
"List.rec",
"instBEqOfDecidableEq",
"Inter.inter",
"List",
"List.instInterOfBEq_batteries",
"_private.Mathlib.Data.List.Lattice.0.List.inter_nil'._proof_1_2",
"Eq",
"L... | induction l with grind | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.