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.Data.Rat.Cast.Lemmas | {
"line": 70,
"column": 26
} | {
"line": 70,
"column": 34
} | [
{
"pp": "K : Type u_1\ninst✝ : DivisionSemiring K\nq : ℚ≥0\nn : ℕ\n⊢ ↑(q ^ n).num / ↑(q ^ n).den = (↑q.num / ↑q.den) ^ n",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHDiv",
"GroupWithZero.toDivInvMonoid",
"congrArg",
"CommSemiring.toSemir... | den_pow, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Basic | {
"line": 238,
"column": 2
} | {
"line": 242,
"column": 7
} | [
{
"pp": "a b : ℕ+\n⊢ ↑(a - b) = if b < a then ↑a - ↑b else 1",
"usedConstants": [
"PNat.val",
"Iff.mpr",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Nat.instOrderedSub",
"Preorder.toLT",
"instLinearOrderPNat",
"congrArg",
"AddMonoid.toAddZeroClass",
... | change (toPNat' _ : ℕ) = ite _ _ _
split_ifs with h
· exact toPNat'_coe (tsub_pos_of_lt h)
· rw [tsub_eq_zero_iff_le.mpr (le_of_not_gt h : (a : ℕ) ≤ b)]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PNat.Basic | {
"line": 238,
"column": 2
} | {
"line": 242,
"column": 7
} | [
{
"pp": "a b : ℕ+\n⊢ ↑(a - b) = if b < a then ↑a - ↑b else 1",
"usedConstants": [
"PNat.val",
"Iff.mpr",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Nat.instOrderedSub",
"Preorder.toLT",
"instLinearOrderPNat",
"congrArg",
"AddMonoid.toAddZeroClass",
... | change (toPNat' _ : ℕ) = ite _ _ _
split_ifs with h
· exact toPNat'_coe (tsub_pos_of_lt h)
· rw [tsub_eq_zero_iff_le.mpr (le_of_not_gt h : (a : ℕ) ≤ b)]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Group.Basic | {
"line": 36,
"column": 2
} | {
"line": 36,
"column": 45
} | [
{
"pp": "α : Type u_1\ninst✝² : CommGroup α\ninst✝¹ : PartialOrder α\ninst✝ : IsOrderedMonoid α\na : α\nha : a < 1\n⊢ StrictAnti fun n ↦ a ^ n",
"usedConstants": [
"PartialOrder.toPreorder",
"DivInvMonoid.toZPow",
"Int",
"Group.toDivInvMonoid",
"HPow.hPow",
"strictAnti_in... | refine strictAnti_int_of_succ_lt fun n ↦ ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Algebra.Order.Group.Basic | {
"line": 109,
"column": 4
} | {
"line": 109,
"column": 12
} | [
{
"pp": "case inl\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⁻¹\nk : ℤ\nhab : a < (fun x ↦ a ^ x) k\nhb : (fun x ↦ a ^ x) k < 1\n⊢ a⁻¹ ^ 0 < a⁻¹ ^ k ∧ a... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.Order.Group.Basic | {
"line": 116,
"column": 4
} | {
"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\nk : ℤ\nhb : 1 < (fun x ↦ a ^ x) k\nhba : (fun x ↦ a ^ x) k < a\n⊢ a ^ 0 < a ^ k ∧ a ^... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Rat.Floor | {
"line": 96,
"column": 56
} | {
"line": 98,
"column": 45
} | [
{
"pp": "α : Type u_1\ninst✝³ : Field α\ninst✝² : LinearOrder α\ninst✝¹ : IsStrictOrderedRing α\ninst✝ : FloorRing α\nx : ℚ\n⊢ round ↑x = round x",
"usedConstants": [
"Rat.instOfNat",
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"GroupWithZero.toDivisionMonoid",
"DivInvOne... | by
have : ((x + 1 / 2 : ℚ) : α) = x + 1 / 2 := by simp
rw [round_eq, round_eq, ← this, floor_cast] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 145,
"column": 6
} | {
"line": 145,
"column": 22
} | [
{
"pp": "R : Type u_2\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : FloorRing R\nz : ℤ\na : R\n⊢ ⌊a⌋ = z ↔ ↑z ≤ a ∧ a < ↑z + 1",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Preorder.toLT",
"Int.floor",
"congrArg",
"PartialOrder.toPreorder",
"AddGroupWithOne.toAddM... | le_antisymm_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.AddTorsor.Defs | {
"line": 110,
"column": 2
} | {
"line": 110,
"column": 28
} | [
{
"pp": "G : Type u_1\nP : Type u_2\ninst✝ : AddGroup G\nT : AddTorsor G P\ng : G\np₁ p₂ : P\n⊢ (g +ᵥ p₁) -ᵥ p₂ = g + (p₁ -ᵥ p₂)",
"usedConstants": [
"AddMonoid.toAddSemigroup",
"AddTorsor.toVSub",
"VSub.vsub",
"HVAdd.hVAdd",
"vadd_right_cancel",
"AddAction.toAddSemigroup... | apply vadd_right_cancel p₂ | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 279,
"column": 93
} | {
"line": 280,
"column": 64
} | [
{
"pp": "R : Type u_4\ninst✝³ : Ring R\ninst✝² : LinearOrder R\ninst✝¹ : IsStrictOrderedRing R\ninst✝ : FloorRing R\nn : ℤ\nhn : 0 < n\na : R\n⊢ ⌊↑n * a⌋ / n = ⌊a⌋",
"usedConstants": [
"Int.mul_cast_floor_div_cancel_of_pos",
"Int.cast",
"Eq.mpr",
"Int.instDiv",
"instHDiv",
... | by
rw [Commute.intCast_left, mul_cast_floor_div_cancel_of_pos hn] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 605,
"column": 80
} | {
"line": 605,
"column": 96
} | [
{
"pp": "R : Type u_2\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : FloorRing R\nz : ℤ\na : R\n⊢ ⌈a⌉ = z ↔ z ≤ ⌈a⌉ ∧ ⌈a⌉ ≤ z",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"id",
"Int",
... | le_antisymm_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 740,
"column": 2
} | {
"line": 742,
"column": 8
} | [
{
"pp": "case inr.h\nR : Type u_2\ninst✝³ : Ring R\ninst✝² : LinearOrder R\ninst✝¹ : FloorRing R\ninst✝ : IsOrderedRing R\na : R\nha : fract a ≠ 0\n⊢ fract a = a + 1 - ↑⌈a⌉",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.floor",
"AddGroupWithOne.toAddGroup",
"congrArg",
"... | suffices (⌈a⌉ : R) = ⌊a⌋ + 1 by
rw [this, ← self_sub_fract]
abel | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSuffices__1 | Lean.Parser.Tactic.tacticSuffices_ |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 794,
"column": 4
} | {
"line": 794,
"column": 33
} | [
{
"pp": "case inr\nk : Type u_4\ninst✝³ : Field k\ninst✝² : LinearOrder k\ninst✝¹ : IsOrderedRing k\ninst✝ : FloorRing k\na b : k\nhb : 1 < b\nhba✝ : ↑⌈(b - 1)⁻¹⌉ / b ≤ a\nhba : ↑⌈(b - 1)⁻¹⌉ / b < a\n⊢ ↑⌈a⌉ ≤ b * a",
"usedConstants": [
"Int.cast",
"HMul.hMul",
"PartialOrder.toPreorder",
... | exact (ceil_lt_mul hb hba).le | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 794,
"column": 4
} | {
"line": 794,
"column": 33
} | [
{
"pp": "case inr\nk : Type u_4\ninst✝³ : Field k\ninst✝² : LinearOrder k\ninst✝¹ : IsOrderedRing k\ninst✝ : FloorRing k\na b : k\nhb : 1 < b\nhba✝ : ↑⌈(b - 1)⁻¹⌉ / b ≤ a\nhba : ↑⌈(b - 1)⁻¹⌉ / b < a\n⊢ ↑⌈a⌉ ≤ b * a",
"usedConstants": [
"Int.cast",
"HMul.hMul",
"PartialOrder.toPreorder",
... | exact (ceil_lt_mul hb hba).le | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 794,
"column": 4
} | {
"line": 794,
"column": 33
} | [
{
"pp": "case inr\nk : Type u_4\ninst✝³ : Field k\ninst✝² : LinearOrder k\ninst✝¹ : IsOrderedRing k\ninst✝ : FloorRing k\na b : k\nhb : 1 < b\nhba✝ : ↑⌈(b - 1)⁻¹⌉ / b ≤ a\nhba : ↑⌈(b - 1)⁻¹⌉ / b < a\n⊢ ↑⌈a⌉ ≤ b * a",
"usedConstants": [
"Int.cast",
"HMul.hMul",
"PartialOrder.toPreorder",
... | exact (ceil_lt_mul hb hba).le | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Count | {
"line": 37,
"column": 82
} | {
"line": 37,
"column": 94
} | [
{
"pp": "α : Type u_1\ninst✝¹ : BEq α\ninst✝ : LawfulBEq α\nl : List α\na : α\n⊢ count a l < l.length ↔ ∃ b, b ∈ l ∧ b ≠ a",
"usedConstants": [
"List.countP",
"beq_eq_false_iff_ne._simp_1",
"congrArg",
"Membership.mem",
"Exists",
"iff_self",
"funext",
"List",
... | simp [count] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Count | {
"line": 37,
"column": 82
} | {
"line": 37,
"column": 94
} | [
{
"pp": "α : Type u_1\ninst✝¹ : BEq α\ninst✝ : LawfulBEq α\nl : List α\na : α\n⊢ count a l < l.length ↔ ∃ b, b ∈ l ∧ b ≠ a",
"usedConstants": [
"List.countP",
"beq_eq_false_iff_ne._simp_1",
"congrArg",
"Membership.mem",
"Exists",
"iff_self",
"funext",
"List",
... | simp [count] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Count | {
"line": 37,
"column": 82
} | {
"line": 37,
"column": 94
} | [
{
"pp": "α : Type u_1\ninst✝¹ : BEq α\ninst✝ : LawfulBEq α\nl : List α\na : α\n⊢ count a l < l.length ↔ ∃ b, b ∈ l ∧ b ≠ a",
"usedConstants": [
"List.countP",
"beq_eq_false_iff_ne._simp_1",
"congrArg",
"Membership.mem",
"Exists",
"iff_self",
"funext",
"List",
... | simp [count] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.AddSub | {
"line": 91,
"column": 2
} | {
"line": 91,
"column": 51
} | [
{
"pp": "α : Type u_1\ns t : Multiset α\n⊢ s ≤ t + s",
"usedConstants": [
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Multiset",
"Eq.mp",
"LE.le",
"Multiset.zero_add",
"instHAdd",
"HAdd.hAdd",
"Multiset.add_le_add_right",
"Zero.t... | simpa using Multiset.add_le_add_right (zero_le t) | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Data.Multiset.AddSub | {
"line": 91,
"column": 2
} | {
"line": 91,
"column": 51
} | [
{
"pp": "α : Type u_1\ns t : Multiset α\n⊢ s ≤ t + s",
"usedConstants": [
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Multiset",
"Eq.mp",
"LE.le",
"Multiset.zero_add",
"instHAdd",
"HAdd.hAdd",
"Multiset.add_le_add_right",
"Zero.t... | simpa using Multiset.add_le_add_right (zero_le t) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Multiset.AddSub | {
"line": 91,
"column": 2
} | {
"line": 91,
"column": 51
} | [
{
"pp": "α : Type u_1\ns t : Multiset α\n⊢ s ≤ t + s",
"usedConstants": [
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Multiset",
"Eq.mp",
"LE.le",
"Multiset.zero_add",
"instHAdd",
"HAdd.hAdd",
"Multiset.add_le_add_right",
"Zero.t... | simpa using Multiset.add_le_add_right (zero_le t) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.AddSub | {
"line": 357,
"column": 12
} | {
"line": 357,
"column": 20
} | [
{
"pp": "case a.isTrue\nα : Type u_1\ninst✝ : DecidableEq α\na : α\ns : Multiset α\na✝ : α\nh✝ : a✝ = a\n⊢ count a✝ s - 1 = count a✝ (s.erase a)",
"usedConstants": [
"congrArg",
"HSub.hSub",
"Multiset.count",
"Multiset",
"Multiset.count.congr_simp",
"instSubNat",
"i... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Multiset.AddSub | {
"line": 357,
"column": 12
} | {
"line": 357,
"column": 20
} | [
{
"pp": "case a.isFalse\nα : Type u_1\ninst✝ : DecidableEq α\na : α\ns : Multiset α\na✝ : α\nh✝ : ¬a✝ = a\n⊢ count a✝ s - 0 = count a✝ (s.erase a)",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"Multiset.count",
"Nat",
"True",
"Multiset.erase",
"eq_self... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Nodup | {
"line": 240,
"column": 6
} | {
"line": 240,
"column": 14
} | [
{
"pp": "case pos\nα : Type u\na : α\nl : List α\nih : l[0]? = l.getLast? → (l.reverse.tail.Nodup ↔ l.tail.Nodup)\nh : (a :: l)[0]? = (a :: l).getLast?\nhl : l = []\n⊢ (a :: l).reverse.tail.Nodup ↔ (a :: l).tail.Nodup",
"usedConstants": [
"congrArg",
"List.nodup_nil._simp_1",
"List.tail",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Nodup | {
"line": 240,
"column": 6
} | {
"line": 240,
"column": 14
} | [
{
"pp": "case pos\nα : Type u\na : α\nl : List α\nih : l[0]? = l.getLast? → (l.reverse.tail.Nodup ↔ l.tail.Nodup)\nh : (a :: l)[0]? = (a :: l).getLast?\nhl : l = []\n⊢ (a :: l).reverse.tail.Nodup ↔ (a :: l).tail.Nodup",
"usedConstants": [
"congrArg",
"List.nodup_nil._simp_1",
"List.tail",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Nodup | {
"line": 240,
"column": 6
} | {
"line": 240,
"column": 14
} | [
{
"pp": "case pos\nα : Type u\na : α\nl : List α\nih : l[0]? = l.getLast? → (l.reverse.tail.Nodup ↔ l.tail.Nodup)\nh : (a :: l)[0]? = (a :: l).getLast?\nhl : l = []\n⊢ (a :: l).reverse.tail.Nodup ↔ (a :: l).tail.Nodup",
"usedConstants": [
"congrArg",
"List.nodup_nil._simp_1",
"List.tail",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.ZeroCons | {
"line": 226,
"column": 6
} | {
"line": 226,
"column": 14
} | [
{
"pp": "case pos\nα : Type u_1\na : α\nas bs : Multiset α\nthis : DecidableEq α\neq : a ::ₘ as = a ::ₘ bs\n⊢ a = a ∧ as = bs ∨ a ≠ a ∧ ∃ cs, as = a ::ₘ cs ∧ bs = a ::ₘ cs",
"usedConstants": [
"False",
"congrArg",
"and_self",
"Multiset.cons_inj_right._simp_1",
"false_and",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Dedup | {
"line": 138,
"column": 10
} | {
"line": 138,
"column": 30
} | [
{
"pp": "case pos\nα : Type u_1\nβ : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : DecidableEq β\nf : α → β\nhf : Function.Injective f\nx : α\nxs : List α\nih : (map f xs).dedup = map f xs.dedup\nh : x ∈ xs\n⊢ (f x :: map f xs).dedup = map f (x :: xs).dedup",
"usedConstants": [
"Eq.mpr",
"congrArg",... | dedup_cons_of_mem h, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Perm.Lattice | {
"line": 75,
"column": 4
} | {
"line": 75,
"column": 61
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : DecidableEq α\nxs ys : List α\nn : ℕ\nh : xs ~ ys\nh' : ys.Nodup\nh'' : n ≤ xs.length\nn' : ℕ := xs.length - n\n⊢ List.drop n xs ~ ys ∩ List.drop n xs",
"usedConstants": [
"Eq.mpr",
"Nat.sub_sub_self",
"congrArg",
"HSub.hSub",
"id",
... | have h₀ : n = xs.length - n' := by rwa [Nat.sub_sub_self] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.List.Lattice | {
"line": 117,
"column": 16
} | {
"line": 117,
"column": 24
} | [
{
"pp": "case pos\nα : Type u_1\nl₂ : List α\na : α\ninst✝ : DecidableEq α\nl₁ : List α\nh✝ : a ∈ l₂\n⊢ (a :: l₁) ∩ l₂ = a :: l₁ ∩ l₂",
"usedConstants": [
"congrArg",
"instBEqOfDecidableEq",
"List.cons",
"Inter.inter",
"List",
"List.instInterOfBEq_batteries",
"True"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Lattice | {
"line": 117,
"column": 16
} | {
"line": 117,
"column": 24
} | [
{
"pp": "case neg\nα : Type u_1\nl₂ : List α\na : α\ninst✝ : DecidableEq α\nl₁ : List α\nh✝ : ¬a ∈ l₂\n⊢ (a :: l₁) ∩ l₂ = l₁ ∩ l₂",
"usedConstants": [
"List.inter_cons_of_notMem",
"False",
"eq_false",
"congrArg",
"Membership.mem",
"instBEqOfDecidableEq",
"List.cons"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Lattice | {
"line": 200,
"column": 16
} | {
"line": 200,
"column": 24
} | [
{
"pp": "case pos\nα : Type u_1\nl₁ l₂ : List α\na : α\ninst✝ : DecidableEq α\nh✝ : a ∈ l₂\n⊢ (a :: l₁).bagInter l₂ = a :: l₁.bagInter (l₂.erase a)",
"usedConstants": [
"congrArg",
"instBEqOfDecidableEq",
"List.cons",
"List",
"List.erase",
"True",
"List.cons_bagInte... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Lattice | {
"line": 200,
"column": 16
} | {
"line": 200,
"column": 24
} | [
{
"pp": "case neg\nα : Type u_1\nl₁ l₂ : List α\na : α\ninst✝ : DecidableEq α\nh✝ : ¬a ∈ l₂\n⊢ (a :: l₁).bagInter l₂ = l₁.bagInter l₂",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"List.cons_bagInter_of_not_mem",
"Membership.mem",
"instBEqOfDecidableEq",
"Li... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Lattice | {
"line": 263,
"column": 6
} | {
"line": 263,
"column": 14
} | [
{
"pp": "case cons.isFalse\nα : Type u_1\ninst✝ : DecidableEq α\nhead✝ : α\ntail✝ : List α\nih : ∀ {l₂ : List α}, tail✝.bagInter l₂ <+ tail✝ ∩ l₂\nl₂ : List α\nh✝ : ¬head✝ ∈ l₂\n⊢ tail✝.bagInter l₂ <+ (head✝ :: tail✝) ∩ l₂",
"usedConstants": [
"List.inter_cons_of_notMem",
"False",
"eq_fals... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Lattice | {
"line": 263,
"column": 6
} | {
"line": 263,
"column": 14
} | [
{
"pp": "case cons.isFalse\nα : Type u_1\ninst✝ : DecidableEq α\nhead✝ : α\ntail✝ : List α\nih : ∀ {l₂ : List α}, tail✝.bagInter l₂ <+ tail✝ ∩ l₂\nl₂ : List α\nh✝ : ¬head✝ ∈ l₂\n⊢ tail✝.bagInter l₂ <+ (head✝ :: tail✝) ∩ l₂",
"usedConstants": [
"List.inter_cons_of_notMem",
"False",
"eq_fals... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Lattice | {
"line": 263,
"column": 6
} | {
"line": 263,
"column": 14
} | [
{
"pp": "case cons.isFalse\nα : Type u_1\ninst✝ : DecidableEq α\nhead✝ : α\ntail✝ : List α\nih : ∀ {l₂ : List α}, tail✝.bagInter l₂ <+ tail✝ ∩ l₂\nl₂ : List α\nh✝ : ¬head✝ ∈ l₂\n⊢ tail✝.bagInter l₂ <+ (head✝ :: tail✝) ∩ l₂",
"usedConstants": [
"List.inter_cons_of_notMem",
"False",
"eq_fals... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.UnionInter | {
"line": 190,
"column": 4
} | {
"line": 190,
"column": 45
} | [
{
"pp": "case a\nα : Type u_1\ninst✝ : DecidableEq α\ns t : Multiset α\n⊢ s + t ≤ s ∪ t + s ∩ t",
"usedConstants": [
"Eq.mpr",
"Multiset.add_inter_distrib",
"Multiset.instInter",
"congrArg",
"PartialOrder.toPreorder",
"Multiset.add_comm",
"Preorder.toLE",
"Mul... | rw [Multiset.add_comm, add_inter_distrib] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Multiset.UnionInter | {
"line": 199,
"column": 31
} | {
"line": 199,
"column": 40
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : DecidableEq α\nt✝ : Multiset α\na : α\nt : Multiset α\nIH : ∀ (s : Multiset α), s - t + t ∩ s = s\ns : Multiset α\nh : a ∈ s\n⊢ s - a ::ₘ t + a ::ₘ t ∩ s.erase a = s",
"usedConstants": [
"Eq.mpr",
"Multiset.instInter",
"congrArg",
"HSub.hSub",... | sub_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Multiset.Basic | {
"line": 52,
"column": 2
} | {
"line": 52,
"column": 28
} | [
{
"pp": "α : Type u_1\na : α\ns : Multiset α\n⊢ a ∈ s.toList ↔ a ∈ s",
"usedConstants": [
"Eq.mpr",
"Multiset.coe_toList",
"Multiset.mem_coe",
"congrArg",
"Iff.rfl",
"Membership.mem",
"Multiset",
"id",
"Multiset.toList",
"Multiset.instMembership",
... | rw [← mem_coe, coe_toList] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Multiset.Basic | {
"line": 52,
"column": 2
} | {
"line": 52,
"column": 28
} | [
{
"pp": "α : Type u_1\na : α\ns : Multiset α\n⊢ a ∈ s.toList ↔ a ∈ s",
"usedConstants": [
"Eq.mpr",
"Multiset.coe_toList",
"Multiset.mem_coe",
"congrArg",
"Iff.rfl",
"Membership.mem",
"Multiset",
"id",
"Multiset.toList",
"Multiset.instMembership",
... | rw [← mem_coe, coe_toList] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Multiset.Basic | {
"line": 52,
"column": 2
} | {
"line": 52,
"column": 28
} | [
{
"pp": "α : Type u_1\na : α\ns : Multiset α\n⊢ a ∈ s.toList ↔ a ∈ s",
"usedConstants": [
"Eq.mpr",
"Multiset.coe_toList",
"Multiset.mem_coe",
"congrArg",
"Iff.rfl",
"Membership.mem",
"Multiset",
"id",
"Multiset.toList",
"Multiset.instMembership",
... | rw [← mem_coe, coe_toList] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.UnionInter | {
"line": 200,
"column": 31
} | {
"line": 200,
"column": 40
} | [
{
"pp": "case neg\nα : Type u_1\ninst✝ : DecidableEq α\nt✝ : Multiset α\na : α\nt : Multiset α\nIH : ∀ (s : Multiset α), s - t + t ∩ s = s\ns : Multiset α\nh : ¬a ∈ s\n⊢ s - a ::ₘ t + t ∩ s = s",
"usedConstants": [
"Eq.mpr",
"Multiset.instInter",
"congrArg",
"HSub.hSub",
"Multi... | sub_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Multiset.Filter | {
"line": 149,
"column": 2
} | {
"line": 149,
"column": 59
} | [
{
"pp": "α : Type u_1\np : α → Prop\ninst✝ : DecidablePred p\ns : Multiset α\n⊢ filter p s + filter (fun a ↦ ¬p a) s = s",
"usedConstants": [
"Iff.mpr",
"Multiset.filter_eq_self",
"Eq.mpr",
"instDecidableNot",
"congrArg",
"Multiset.filter_add_filter",
"Membership.me... | rw [filter_add_filter, filter_eq_self.2, filter_eq_nil.2] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Multiset.Filter | {
"line": 366,
"column": 6
} | {
"line": 366,
"column": 15
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\np : α → Prop\ninst✝ : DecidablePred p\nt✝ : Multiset α\na : α\nt : Multiset α\nIH : ∀ (s : Multiset α), filter p (s - t) = filter p s - filter p t\ns : Multiset α\n⊢ filter p (s - a ::ₘ t) = filter p s - filter p (a ::ₘ t)",
"usedConstants": [
"Eq.mpr",
... | sub_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Infix | {
"line": 155,
"column": 30
} | {
"line": 155,
"column": 38
} | [
{
"pp": "case mp.nil\nα : Type u_1\nx y : α\nbs : List α\nh : [] ++ [x] ++ bs = [y]\n⊢ x = y",
"usedConstants": [
"congrArg",
"Eq.mp",
"id",
"List.cons",
"List.cons.injEq",
"instHAppendOfAppend",
"List",
"And",
"True",
"eq_self",
"of_eq_true"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Infix | {
"line": 155,
"column": 30
} | {
"line": 155,
"column": 38
} | [
{
"pp": "case mp.cons\nα : Type u_1\nx y head✝ : α\ntail✝ bs : List α\nh : head✝ :: tail✝ ++ [x] ++ bs = [y]\n⊢ x = y",
"usedConstants": [
"False",
"List.append_assoc",
"congrArg",
"List.append_eq_nil_iff._simp_1",
"False.elim",
"noConfusion_of_Nat",
"Eq.mp",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Infix | {
"line": 165,
"column": 6
} | {
"line": 165,
"column": 26
} | [
{
"pp": "case mp\nα : Type u_1\nxs : List α\nx head✝¹ head✝ : α\ntail✝ : List α\n⊢ head✝¹ :: head✝ :: tail✝ <:+: [x] → head✝¹ :: head✝ :: tail✝ = [] ∨ head✝¹ :: head✝ :: tail✝ = [x]",
"usedConstants": [
"List.cons",
"List.IsInfix",
"List.nil"
]
}
] | rintro ⟨_ | _, _, h⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Data.Multiset.FinsetOps | {
"line": 250,
"column": 92
} | {
"line": 251,
"column": 54
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : Multiset α\n⊢ s.ndinter t = 0 ↔ _root_.Disjoint s t",
"usedConstants": [
"_private.Mathlib.Data.Multiset.FinsetOps.0.Multiset.ndinter_eq_zero_iff_disjoint._simp_1_1",
"Eq.mpr",
"False",
"Multiset.notMem_zero._simp_1",
"congrAr... | by
rw [← subset_zero]; simp [subset_iff, disjoint_left] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.Basic | {
"line": 120,
"column": 29
} | {
"line": 120,
"column": 37
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Finset α\na : α\nhs : s.Nontrivial\n⊢ ∀ (a_1 : α), a_1 ∈ s ∧ a_1 ≠ a → a_1 ∈ s.erase a",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"and_self",
"Finset",
"Membership.mem",
"Ne",
"And",
"Finset.me... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Finset.Basic | {
"line": 120,
"column": 29
} | {
"line": 120,
"column": 37
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Finset α\na : α\nhs : s.Nontrivial\n⊢ ∀ (a_1 : α), a_1 ∈ s ∧ a_1 ≠ a → a_1 ∈ s.erase a",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"and_self",
"Finset",
"Membership.mem",
"Ne",
"And",
"Finset.me... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Basic | {
"line": 120,
"column": 29
} | {
"line": 120,
"column": 37
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Finset α\na : α\nhs : s.Nontrivial\n⊢ ∀ (a_1 : α), a_1 ∈ s ∧ a_1 ≠ a → a_1 ∈ s.erase a",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"and_self",
"Finset",
"Membership.mem",
"Ne",
"And",
"Finset.me... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fin.Embedding | {
"line": 94,
"column": 4
} | {
"line": 94,
"column": 39
} | [
{
"pp": "case succ\nn : ℕ\nihn : ∀ {m : ℕ}, Nonempty (Fin n ↪ Fin m) → n ≤ m\nm : ℕ\ne : Fin (n + 1) ↪ Fin m.succ\n⊢ n + 1 ≤ m.succ",
"usedConstants": [
"Nonempty.intro",
"Function.Embedding",
"Fin",
"Nat.succ_le_succ"
]
}
] | refine Nat.succ_le_succ <| ihn ⟨?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Fin.SuccPred | {
"line": 177,
"column": 2
} | {
"line": 177,
"column": 42
} | [
{
"pp": "n : ℕ\na b : Fin (n + 1)\ni : Fin n\nhl : i.castSucc < a\nhu : b < i.succ\n⊢ b < a",
"usedConstants": [
"Eq.mpr",
"Fin.succ",
"_private.Mathlib.Data.Fin.SuccPred.0.Fin.le_of_castSucc_lt_of_succ_lt._proof_1_2",
"Eq.mp",
"id",
"instOfNatNat",
"Fin.val",
... | simp [Fin.lt_def, -val_fin_lt] at *; lia | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.SuccPred | {
"line": 177,
"column": 2
} | {
"line": 177,
"column": 42
} | [
{
"pp": "n : ℕ\na b : Fin (n + 1)\ni : Fin n\nhl : i.castSucc < a\nhu : b < i.succ\n⊢ b < a",
"usedConstants": [
"Eq.mpr",
"Fin.succ",
"_private.Mathlib.Data.Fin.SuccPred.0.Fin.le_of_castSucc_lt_of_succ_lt._proof_1_2",
"Eq.mp",
"id",
"instOfNatNat",
"Fin.val",
... | simp [Fin.lt_def, -val_fin_lt] at *; lia | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Card | {
"line": 259,
"column": 66
} | {
"line": 259,
"column": 74
} | [
{
"pp": "α : Type u_1\ns : Finset α\nP : α → Prop\ninst✝ : DecidablePred P\nn : ℕ\nH : ∀ s' ≤ s.val, n < s'.card → ∃ a ∈ s', ¬P a\ns' : Finset α\nhs' : s' ⊆ s\nh : n < #s'\n⊢ s'.val ≤ s.val",
"usedConstants": [
"Finset.val_le_iff._simp_1",
"Finset",
"PartialOrder.toPreorder",
"Preord... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Finset.Card | {
"line": 259,
"column": 66
} | {
"line": 259,
"column": 74
} | [
{
"pp": "α : Type u_1\ns : Finset α\nP : α → Prop\ninst✝ : DecidablePred P\nn : ℕ\nH : ∀ s' ≤ s.val, n < s'.card → ∃ a ∈ s', ¬P a\ns' : Finset α\nhs' : s' ⊆ s\nh : n < #s'\n⊢ s'.val ≤ s.val",
"usedConstants": [
"Finset.val_le_iff._simp_1",
"Finset",
"PartialOrder.toPreorder",
"Preord... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Card | {
"line": 259,
"column": 66
} | {
"line": 259,
"column": 74
} | [
{
"pp": "α : Type u_1\ns : Finset α\nP : α → Prop\ninst✝ : DecidablePred P\nn : ℕ\nH : ∀ s' ≤ s.val, n < s'.card → ∃ a ∈ s', ¬P a\ns' : Finset α\nhs' : s' ⊆ s\nh : n < #s'\n⊢ s'.val ≤ s.val",
"usedConstants": [
"Finset.val_le_iff._simp_1",
"Finset",
"PartialOrder.toPreorder",
"Preord... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fin.SuccPred | {
"line": 277,
"column": 38
} | {
"line": 277,
"column": 73
} | [
{
"pp": "n : ℕ\nh : ¬last (n + 1) = 0\n⊢ (last (n + 1)).pred h = last n",
"usedConstants": [
"instNeZeroNatHAdd_1",
"Fin.succ",
"Fin.pred",
"congrArg",
"id",
"Fin.instOfNat",
"Ne",
"instOfNatNat",
"Fin.pred_succ",
"instHAdd",
"HAdd.hAdd",
... | by simp_rw [← succ_last, pred_succ] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Fin.SuccPred | {
"line": 391,
"column": 24
} | {
"line": 391,
"column": 40
} | [
{
"pp": "n : ℕ\ni j : Fin (n + 1)\nhi : i ≠ last n\nhj : j ≠ last n\n⊢ ↑(i.castPred hi) = ↑(j.castPred hj) ↔ ↑i = ↑j",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"Fin.castPred",
"instOfNatNat",
"LE.le",
"Fi... | le_antisymm_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Fin.SuccPred | {
"line": 440,
"column": 41
} | {
"line": 440,
"column": 61
} | [
{
"pp": "n : ℕ\na b : Fin (n + 1)\nha : a ≠ last n\n⊢ b < a.succ.castPred ⋯ ↔ b ≤ a",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Fin.succ",
"congrArg",
"id",
"Fin.castPred",
"Ne",
"instOfNatNat",
"LE.le",
"Fin.succ_ne_last_iff",
"instLEFin",
... | lt_castPred_succ_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fin.SuccPred | {
"line": 638,
"column": 24
} | {
"line": 638,
"column": 39
} | [
{
"pp": "n : ℕ\n⊢ Set.range (succAbove 0) = {0}ᶜ",
"usedConstants": [
"Fin.succAbove",
"Eq.mpr",
"instNeZeroNatHAdd_1",
"congrArg",
"Compl.compl",
"Set.instSingletonSet",
"id",
"Fin.instOfNat",
"instOfNatNat",
"Set.instCompl",
"instHAdd",
... | range_succAbove | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 117,
"column": 2
} | {
"line": 117,
"column": 37
} | [
{
"pp": "n : ℕ\nα : Fin (n + 1) → Sort u\nx : α 0\np : (i : Fin n) → α i.succ\n⊢ tail (cons x p) = p",
"usedConstants": [
"Fin.succ",
"eq_self",
"of_eq_true",
"Fin",
"Eq"
]
}
] | simp +unfoldPartialApp [tail, cons] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 117,
"column": 2
} | {
"line": 117,
"column": 37
} | [
{
"pp": "n : ℕ\nα : Fin (n + 1) → Sort u\nx : α 0\np : (i : Fin n) → α i.succ\n⊢ tail (cons x p) = p",
"usedConstants": [
"Fin.succ",
"eq_self",
"of_eq_true",
"Fin",
"Eq"
]
}
] | simp +unfoldPartialApp [tail, cons] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 117,
"column": 2
} | {
"line": 117,
"column": 37
} | [
{
"pp": "n : ℕ\nα : Fin (n + 1) → Sort u\nx : α 0\np : (i : Fin n) → α i.succ\n⊢ tail (cons x p) = p",
"usedConstants": [
"Fin.succ",
"eq_self",
"of_eq_true",
"Fin",
"Eq"
]
}
] | simp +unfoldPartialApp [tail, cons] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 205,
"column": 2
} | {
"line": 205,
"column": 25
} | [
{
"pp": "n : ℕ\nα : Type u_1\nx₀ : α\nx : Fin n → α\nhx₀ : ¬x₀ ∈ Set.range x\nhx : Injective x\ni j : Fin (n + 1)\n⊢ cons x₀ x i = cons x₀ x j → i = j",
"usedConstants": [
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Eq.refl",
"OfNat.ofNat",
... | cases i using Fin.cases | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Data.Finset.Card | {
"line": 756,
"column": 60
} | {
"line": 756,
"column": 68
} | [
{
"pp": "α : Type u_1\ns✝ : Finset α\nn : ℕ\na : α\ns : Finset α\nx✝² : a ∉ s\nx✝¹ : #s = n + 1 → ∃ a t, ∃ (h : a ∉ t), cons a t h = s ∧ #t = n\nx✝ : #(cons a s x✝²) = n + 1\n⊢ ∃ (h : a ∉ s), cons a s h = cons a s x✝² ∧ #s = n",
"usedConstants": [
"False",
"eq_false",
"Iff.of_eq",
"F... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Finset.Card | {
"line": 756,
"column": 60
} | {
"line": 756,
"column": 68
} | [
{
"pp": "α : Type u_1\ns✝ : Finset α\nn : ℕ\na : α\ns : Finset α\nx✝² : a ∉ s\nx✝¹ : #s = n + 1 → ∃ a t, ∃ (h : a ∉ t), cons a t h = s ∧ #t = n\nx✝ : #(cons a s x✝²) = n + 1\n⊢ ∃ (h : a ∉ s), cons a s h = cons a s x✝² ∧ #s = n",
"usedConstants": [
"False",
"eq_false",
"Iff.of_eq",
"F... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Card | {
"line": 756,
"column": 60
} | {
"line": 756,
"column": 68
} | [
{
"pp": "α : Type u_1\ns✝ : Finset α\nn : ℕ\na : α\ns : Finset α\nx✝² : a ∉ s\nx✝¹ : #s = n + 1 → ∃ a t, ∃ (h : a ∉ t), cons a t h = s ∧ #t = n\nx✝ : #(cons a s x✝²) = n + 1\n⊢ ∃ (h : a ∉ s), cons a s h = cons a s x✝² ∧ #s = n",
"usedConstants": [
"False",
"eq_false",
"Iff.of_eq",
"F... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Duplicate | {
"line": 83,
"column": 4
} | {
"line": 85,
"column": 28
} | [
{
"pp": "case refine_2\nα : Type u_1\nl : List α\nx y : α\nh : y = x ∧ x ∈ l ∨ x ∈+ l\n⊢ x ∈+ y :: l",
"usedConstants": [
"List.Duplicate.cons_duplicate",
"Eq.mpr",
"HEq.refl",
"List.duplicate_cons_self_iff._simp_1",
"Membership.mem",
"Eq.casesOn",
"id",
"Or.c... | rcases h with (⟨rfl | h⟩ | h)
· simpa
· exact h.cons_duplicate | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Duplicate | {
"line": 83,
"column": 4
} | {
"line": 85,
"column": 28
} | [
{
"pp": "case refine_2\nα : Type u_1\nl : List α\nx y : α\nh : y = x ∧ x ∈ l ∨ x ∈+ l\n⊢ x ∈+ y :: l",
"usedConstants": [
"List.Duplicate.cons_duplicate",
"Eq.mpr",
"HEq.refl",
"List.duplicate_cons_self_iff._simp_1",
"Membership.mem",
"Eq.casesOn",
"id",
"Or.c... | rcases h with (⟨rfl | h⟩ | h)
· simpa
· exact h.cons_duplicate | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Card | {
"line": 795,
"column": 6
} | {
"line": 795,
"column": 51
} | [
{
"pp": "case mp\nα : Type u_1\ns : Finset α\n⊢ (∃ b b_1 b_2, ∃ a ⊆ s, b ≠ b_1 ∧ b ≠ b_2 ∧ b_1 ≠ b_2 ∧ a = {b, b_1, b_2}) →\n ∃ a b c, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ a ≠ b ∧ a ≠ c ∧ b ≠ c",
"usedConstants": [
"Finset",
"Classical.propDecidable",
"Exists",
"Insert.insert",
"HasSubse... | rintro ⟨a, b, c, t, hsub, hab, hac, hbc, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Data.List.NodupEquivFin | {
"line": 128,
"column": 80
} | {
"line": 128,
"column": 84
} | [
{
"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\nf' : ℕ ↪o ℕ := OrderEmbedding.ofMapLEIff (fun i ↦ f (i + 1) - (f 0 + 1)) ⋯\ni... | ← hf | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.NodupEquivFin | {
"line": 212,
"column": 16
} | {
"line": 212,
"column": 20
} | [
{
"pp": "case mp\nα : Type u_1\nl : List α\nx : α\nf : Fin (replicate 2 x).length ↪o Fin l.length\nhf : ∀ (ix : Fin (replicate 2 x).length), (replicate 2 x).get ix = l.get (f ix)\n⊢ x = (replicate 2 x).get ⟨0, ⋯⟩ ∧ x = l.get (f ⟨1, ⋯⟩)",
"usedConstants": [
"Eq.mpr",
"List.replicate",
"Nat.... | ← hf | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 661,
"column": 2
} | {
"line": 661,
"column": 75
} | [
{
"pp": "n m : ℕ\nα : Sort u_2\nxs : Fin n → α\nx : α\nys : Fin m → α\n⊢ append (snoc xs x) ys = append xs (cons x ys) ∘ Fin.cast ⋯",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Fin.append_assoc",
"Fin.cons",
"Fin.append_left_eq_cons",
"Function.comp",
"Fin.snoc",
... | rw [snoc_eq_append, append_assoc, append_left_eq_cons, append_cast_right] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 857,
"column": 4
} | {
"line": 857,
"column": 30
} | [
{
"pp": "case neg\nn : ℕ\nα : Fin (n + 1) → Sort u_1\ni : Fin (n + 1)\nx : α i\np : (j : Fin n) → α (i.succAbove j)\nj : Fin n\nhlt : ¬j.castSucc < i\n⊢ ⋯ ▸ p ((i.succAbove j).pred ⋯) = p j",
"usedConstants": [
"Fin.succAbove",
"instNeZeroNatHAdd_1",
"_private.Mathlib.Data.Fin.Tuple.Basic.... | generalize_proofs H₀ H₁ H₂ | Batteries.Tactic._aux_Batteries_Tactic_GeneralizeProofs___elabRules_Batteries_Tactic_generalizeProofsElab_1 | Batteries.Tactic.generalizeProofsElab |
Mathlib.Data.Set.Finite.Basic | {
"line": 137,
"column": 69
} | {
"line": 138,
"column": 48
} | [
{
"pp": "α : Type u\ns : Set α\nhs : s.Finite\nt : Finset α\n⊢ hs.toFinset ⊂ t ↔ s ⊂ ↑t",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"Iff.rfl",
"HasSSubset.SSubset",
"Set.instHasSSubset",
"id",
"Set.Finite.coe_toFinset",
"Finset.coe_ssubset",
... | by
rw [← Finset.coe_ssubset, Finite.coe_toFinset] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Set.Finite.Basic | {
"line": 145,
"column": 70
} | {
"line": 146,
"column": 48
} | [
{
"pp": "α : Type u\nt : Set α\nht : t.Finite\ns : Finset α\n⊢ s ⊂ ht.toFinset ↔ ↑s ⊂ t",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"Iff.rfl",
"HasSSubset.SSubset",
"Set.instHasSSubset",
"id",
"Set.Finite.coe_toFinset",
"Finset.coe_ssubset",
... | by
rw [← Finset.coe_ssubset, Finite.coe_toFinset] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Pairwise | {
"line": 65,
"column": 4
} | {
"line": 65,
"column": 13
} | [
{
"pp": "case a\nα : Type u_1\nR : α → α → Prop\nl : List α\ninst✝ : Std.Refl R\nh : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → R a b\na b : α\nhab : [a, b] <+ l\nheq : ¬a = b\n⊢ a ≠ b",
"usedConstants": []
}
] | exact heq | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.List.Pairwise | {
"line": 89,
"column": 6
} | {
"line": 89,
"column": 51
} | [
{
"pp": "α : Type u_1\nR : α → α → Prop\nl : List α\na : α\nh₁ : Pairwise R l\nha : a ∈ l\nhlast : R (l.getLast ⋯) (l.getLast ⋯)\n⊢ R a (l.getLast ⋯)",
"usedConstants": [
"List.getLast",
"congrArg",
"List.dropLast_concat_getLast",
"Membership.mem",
"List.ne_nil_of_mem",
"... | ← dropLast_concat_getLast (ne_nil_of_mem ha), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Sort | {
"line": 200,
"column": 8
} | {
"line": 200,
"column": 16
} | [
{
"pp": "case pos\nα : Type u_1\nr : α → α → Prop\ninst✝¹ : DecidableRel r\ninst✝ : IsTrans α r\nx a : α\nas bs : List α\nhb : Pairwise r (a :: bs)\na✝ : as <+ bs\nhr : r x a\n⊢ x :: a :: as <+ x :: a :: bs",
"usedConstants": [
"List.cons_sublist_cons._simp_1",
"List.cons",
"True",
"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Sort | {
"line": 200,
"column": 8
} | {
"line": 200,
"column": 16
} | [
{
"pp": "case pos\nα : Type u_1\nr : α → α → Prop\ninst✝¹ : DecidableRel r\ninst✝ : IsTrans α r\nx a : α\nas bs : List α\nhb : Pairwise r (a :: bs)\na✝ : as <+ bs\nhr : r x a\n⊢ x :: a :: as <+ x :: a :: bs",
"usedConstants": [
"List.cons_sublist_cons._simp_1",
"List.cons",
"True",
"... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sort | {
"line": 200,
"column": 8
} | {
"line": 200,
"column": 16
} | [
{
"pp": "case pos\nα : Type u_1\nr : α → α → Prop\ninst✝¹ : DecidableRel r\ninst✝ : IsTrans α r\nx a : α\nas bs : List α\nhb : Pairwise r (a :: bs)\na✝ : as <+ bs\nhr : r x a\n⊢ x :: a :: as <+ x :: a :: bs",
"usedConstants": [
"List.cons_sublist_cons._simp_1",
"List.cons",
"True",
"... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Fold | {
"line": 152,
"column": 4
} | {
"line": 156,
"column": 10
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nop : β → β → β\nhc : Std.Commutative op\nha : Std.Associative op\nf : α → β\nb : β\ns : Finset α\nr : β → β → Prop\nhr : ∀ {x y z : β}, r x (op y z) ↔ r x y ∧ r x z\nc : β\n⊢ r c (fold op b f s) ↔ r c b ∧ ∀ x ∈ s, r c (f x)",
"usedConstants": [
"Eq.mpr",
"Fal... | induction s using Finset.induction_on with
| empty => simp
| insert a s ha IH =>
rw [Finset.fold_insert ha, hr, IH, ← and_assoc, @and_comm (r c (f a)), and_assoc]
simp | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Finset.Fold | {
"line": 152,
"column": 4
} | {
"line": 156,
"column": 10
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nop : β → β → β\nhc : Std.Commutative op\nha : Std.Associative op\nf : α → β\nb : β\ns : Finset α\nr : β → β → Prop\nhr : ∀ {x y z : β}, r x (op y z) ↔ r x y ∧ r x z\nc : β\n⊢ r c (fold op b f s) ↔ r c b ∧ ∀ x ∈ s, r c (f x)",
"usedConstants": [
"Eq.mpr",
"Fal... | induction s using Finset.induction_on with
| empty => simp
| insert a s ha IH =>
rw [Finset.fold_insert ha, hr, IH, ← and_assoc, @and_comm (r c (f a)), and_assoc]
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Fold | {
"line": 152,
"column": 4
} | {
"line": 156,
"column": 10
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nop : β → β → β\nhc : Std.Commutative op\nha : Std.Associative op\nf : α → β\nb : β\ns : Finset α\nr : β → β → Prop\nhr : ∀ {x y z : β}, r x (op y z) ↔ r x y ∧ r x z\nc : β\n⊢ r c (fold op b f s) ↔ r c b ∧ ∀ x ∈ s, r c (f x)",
"usedConstants": [
"Eq.mpr",
"Fal... | induction s using Finset.induction_on with
| empty => simp
| insert a s ha IH =>
rw [Finset.fold_insert ha, hr, IH, ← and_assoc, @and_comm (r c (f a)), and_assoc]
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Chain | {
"line": 118,
"column": 41
} | {
"line": 118,
"column": 49
} | [
{
"pp": "case nil\nα : Type u\nR : α → α → Prop\n⊢ IsChain R [] ↔ Forall₂ R [].dropLast [].tail",
"usedConstants": [
"False",
"congrArg",
"Membership.mem",
"List.IsChain",
"List.forall₂_same._simp_1",
"List.dropLast",
"List.not_mem_nil._simp_1",
"List.tail",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Chain | {
"line": 118,
"column": 41
} | {
"line": 118,
"column": 49
} | [
{
"pp": "case singleton\nα : Type u\nR : α → α → Prop\nx✝ : α\n⊢ IsChain R [x✝] ↔ Forall₂ R [x✝].dropLast [x✝].tail",
"usedConstants": [
"False",
"congrArg",
"Membership.mem",
"List.IsChain",
"List.forall₂_same._simp_1",
"List.dropLast",
"List.not_mem_nil._simp_1",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Chain | {
"line": 118,
"column": 41
} | {
"line": 118,
"column": 49
} | [
{
"pp": "case cons_cons\nα : Type u\nR : α → α → Prop\nx✝ y✝ : α\nxs✝ : List α\na✝¹ : IsChain R xs✝ ↔ Forall₂ R xs✝.dropLast xs✝.tail\na✝ : ∀ (y : α), IsChain R (y :: xs✝) ↔ Forall₂ R (y :: xs✝).dropLast (y :: xs✝).tail\n⊢ IsChain R (x✝ :: y✝ :: xs✝) ↔ Forall₂ R (x✝ :: y✝ :: xs✝).dropLast (x✝ :: y✝ :: xs✝).tail... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Chain | {
"line": 318,
"column": 4
} | {
"line": 318,
"column": 30
} | [
{
"pp": "case refine_2\nα : Type u\nr : α → α → Prop\na b : α\nh : Relation.ReflTransGen r a b\nc d : α\ne : r c d\nh✝ : Relation.ReflTransGen r d b\nih : ∃ l, IsChain r (d :: l) ∧ (d :: l).getLast ⋯ = b\n⊢ ∃ l, IsChain r (c :: l) ∧ (c :: l).getLast ⋯ = b",
"usedConstants": []
}
] | obtain ⟨l, hl₁, hl₂⟩ := ih | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.List.Rotate | {
"line": 99,
"column": 47
} | {
"line": 99,
"column": 62
} | [
{
"pp": "α : Type u\nl : List α\nn : ℕ\n⊢ l.rotate' (n % l.length + (l.rotate' (n % l.length)).length * (n / l.length)) = l.rotate' n",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"List.length_rotate'",
"congrArg",
"id",
"HDiv.hDiv",
"Nat.instMod",
... | length_rotate', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Group.Multiset | {
"line": 159,
"column": 41
} | {
"line": 159,
"column": 76
} | [
{
"pp": "case a\nα : Type u_1\ninst✝ : DecidableEq α\ns : Multiset α\nn : ℕ\nhn : n ≠ 0\na : α\n⊢ count a (n • s).dedup = count a s.dedup",
"usedConstants": [
"False",
"instHSMul",
"eq_false",
"Multiset.Nodup",
"congrArg",
"and_self",
"Multiset.dedup",
"AddMon... | by_cases h : a ∈ s <;> simp [h, hn] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.List.Rotate | {
"line": 277,
"column": 38
} | {
"line": 277,
"column": 46
} | [
{
"pp": "α : Type u\nn : ℕ\nl l' : List α\nh : drop (n % l.length) l ++ take (n % l.length) l = drop (n % l'.length) l' ++ take (n % l'.length) l'\nhle : l.length = l'.length\n⊢ (drop (n % l.length) l).length = (drop (n % l'.length) l').length",
"usedConstants": [
"congrArg",
"List.length_drop",... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Rotate | {
"line": 277,
"column": 38
} | {
"line": 277,
"column": 46
} | [
{
"pp": "α : Type u\nn : ℕ\nl l' : List α\nh : drop (n % l.length) l ++ take (n % l.length) l = drop (n % l'.length) l' ++ take (n % l'.length) l'\nhle : l.length = l'.length\n⊢ (drop (n % l.length) l).length = (drop (n % l'.length) l').length",
"usedConstants": [
"congrArg",
"List.length_drop",... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Rotate | {
"line": 277,
"column": 38
} | {
"line": 277,
"column": 46
} | [
{
"pp": "α : Type u\nn : ℕ\nl l' : List α\nh : drop (n % l.length) l ++ take (n % l.length) l = drop (n % l'.length) l' ++ take (n % l'.length) l'\nhle : l.length = l'.length\n⊢ (drop (n % l.length) l).length = (drop (n % l'.length) l').length",
"usedConstants": [
"congrArg",
"List.length_drop",... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Union | {
"line": 157,
"column": 46
} | {
"line": 157,
"column": 54
} | [
{
"pp": "case empty\nα : Type u_1\nβ : Type u_2\nf : α → Finset β\nt : Finset β\nhf : (↑∅).PairwiseDisjoint f\n⊢ Disjoint (∅.disjiUnion f hf) t ↔ ∀ i ∈ ∅, Disjoint (f i) t",
"usedConstants": [
"False",
"congrArg",
"Finset",
"Disjoint",
"Membership.mem",
"Finset.disjiUnion... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Finset.Union | {
"line": 157,
"column": 46
} | {
"line": 157,
"column": 54
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type u_2\nf : α → Finset β\nt : Finset β\na✝¹ : α\ns✝ : Finset α\nh✝ : a✝¹ ∉ s✝\na✝ : ∀ (hf : (↑s✝).PairwiseDisjoint f), Disjoint (s✝.disjiUnion f hf) t ↔ ∀ i ∈ s✝, Disjoint (f i) t\nhf : (↑(cons a✝¹ s✝ h✝)).PairwiseDisjoint f\n⊢ Disjoint ((cons a✝¹ s✝ h✝).disjiUnion f hf) ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Multiset.Bind | {
"line": 347,
"column": 43
} | {
"line": 347,
"column": 51
} | [
{
"pp": "case empty\nα : Type u_1\nβ : Type v\nt : Multiset β\n⊢ map Prod.swap (0 ×ˢ t) = t ×ˢ 0",
"usedConstants": [
"Multiset.instSProd",
"SProd.sprod",
"congrArg",
"Multiset",
"Multiset.product_zero",
"True",
"eq_self",
"of_eq_true",
"Zero.toOfNat0",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Multiset.Bind | {
"line": 347,
"column": 43
} | {
"line": 347,
"column": 51
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type v\nt : Multiset β\na✝¹ : α\ns✝ : Multiset α\na✝ : map Prod.swap (s✝ ×ˢ t) = t ×ˢ s✝\n⊢ map Prod.swap ((a✝¹ ::ₘ s✝) ×ˢ t) = t ×ˢ (a✝¹ ::ₘ s✝)",
"usedConstants": [
"Multiset.product_cons",
"Multiset.map",
"Multiset.instSProd",
"SProd.sprod",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Multiset.Bind | {
"line": 352,
"column": 43
} | {
"line": 352,
"column": 51
} | [
{
"pp": "case empty\nα : Type u_1\nβ : Type v\nM : Type u_4\ninst✝ : CommMonoid M\nt : Multiset β\nf : α × β → M\n⊢ (map f (0 ×ˢ t)).prod = (map (fun i ↦ (map (fun j ↦ f (i, j)) t).prod) 0).prod",
"usedConstants": [
"MulOne.toOne",
"Monoid.toMulOneClass",
"MulOneClass.toMulOne",
"Com... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Multiset.Bind | {
"line": 352,
"column": 43
} | {
"line": 352,
"column": 51
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type v\nM : Type u_4\ninst✝ : CommMonoid M\nt : Multiset β\nf : α × β → M\na✝¹ : α\ns✝ : Multiset α\na✝ : (map f (s✝ ×ˢ t)).prod = (map (fun i ↦ (map (fun j ↦ f (i, j)) t).prod) s✝).prod\n⊢ (map f ((a✝¹ ::ₘ s✝) ×ˢ t)).prod = (map (fun i ↦ (map (fun j ↦ f (i, j)) t).prod) (a... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.