module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 365
values | kind stringclasses 368
values |
|---|---|---|---|---|---|---|
Mathlib.Order.CompleteLattice.Basic | {
"line": 557,
"column": 95
} | {
"line": 560,
"column": 74
} | [
{
"pp": "α : Type u_1\ninst✝¹ : CompleteLattice α\nι : Type u_8\ninst✝ : Preorder ι\nf : ι → α\n⊢ ⨆ i, ⨆ j, ⨆ (_ : j ≥ i), f j = ⨆ i, f i",
"usedConstants": [
"iSup₂_le",
"le_rfl",
"iSup",
"PartialOrder.toPreorder",
"Preorder.toLE",
"GE.ge",
"le_iSup",
"Comple... | by
apply le_antisymm
· exact iSup_le fun _ ↦ iSup₂_le fun _ _ ↦ le_iSup _ _
· exact iSup_le fun j ↦ le_iSup_of_le j (le_iSup₂_of_le j le_rfl le_rfl) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Set.Lattice | {
"line": 371,
"column": 93
} | {
"line": 372,
"column": 43
} | [
{
"pp": "β : Type u_2\nι : Sort u_5\nx : β\nt : ι → Set β\n⊢ insert x (⋂ i, t i) = ⋂ i, insert x (t i)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Set.iInter",
"Set.instUnion",
"Set.iInter_union",
"Set.instSingletonSet",
"id",
"Insert.insert",
"funext",
... | by
simp_rw [← union_singleton, iInter_union] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Set.Lattice | {
"line": 1150,
"column": 2
} | {
"line": 1150,
"column": 92
} | [
{
"pp": "α : Type u_1\nπ : α → Type u_12\ni : Set α\ns t : (a : α) → Set (π a)\nx : (i : α) → π i\nhx : x ∈ i.pi s \\ ⋃ a ∈ i, eval a ⁻¹' (s a \\ t a)\na : α\nha : a ∈ i\n⊢ x a ∈ t a",
"usedConstants": [
"_private.Mathlib.Data.Set.Lattice.0.Set.pi_diff_pi_subset._simp_1_4",
"_private.Mathlib.Dat... | simp only [mem_diff, mem_pi, mem_iUnion, not_exists, mem_preimage, not_and, not_not] at hx | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Order.ConditionallyCompleteLattice.Basic | {
"line": 677,
"column": 14
} | {
"line": 677,
"column": 35
} | [
{
"pp": "case neg.some.refine_1.none\nβ : Type u_5\ninst✝ : ConditionallyCompleteLattice β\ns : Set (WithTop β)\nhs : BddBelow s\na : β\nha✝ : Option.some a ∈ lowerBounds s\nh : (fun a ↦ ↑a) ⁻¹' s = ∅\nha : none ∈ s\n⊢ none ∈ {⊤}",
"usedConstants": [
"Set.mem_singleton",
"WithTop.top",
"To... | exact mem_singleton ⊤ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.ConditionallyCompleteLattice.Basic | {
"line": 677,
"column": 14
} | {
"line": 677,
"column": 35
} | [
{
"pp": "case neg.some.refine_1.none\nβ : Type u_5\ninst✝ : ConditionallyCompleteLattice β\ns : Set (WithTop β)\nhs : BddBelow s\na : β\nha✝ : Option.some a ∈ lowerBounds s\nh : (fun a ↦ ↑a) ⁻¹' s = ∅\nha : none ∈ s\n⊢ none ∈ {⊤}",
"usedConstants": [
"Set.mem_singleton",
"WithTop.top",
"To... | exact mem_singleton ⊤ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.ConditionallyCompleteLattice.Basic | {
"line": 677,
"column": 14
} | {
"line": 677,
"column": 35
} | [
{
"pp": "case neg.some.refine_1.none\nβ : Type u_5\ninst✝ : ConditionallyCompleteLattice β\ns : Set (WithTop β)\nhs : BddBelow s\na : β\nha✝ : Option.some a ∈ lowerBounds s\nh : (fun a ↦ ↑a) ⁻¹' s = ∅\nha : none ∈ s\n⊢ none ∈ {⊤}",
"usedConstants": [
"Set.mem_singleton",
"WithTop.top",
"To... | exact mem_singleton ⊤ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.LatticeIntervals | {
"line": 278,
"column": 47
} | {
"line": 279,
"column": 63
} | [
{
"pp": "α : Type u_1\na b : α\ninst✝¹ : Lattice α\ninst✝ : Fact (a ≤ b)\nx y : ↑(Icc a b)\n⊢ IsCompl x y ↔ ↑x ⊓ ↑y = a ∧ ↑x ⊔ ↑y = b",
"usedConstants": [
"Eq.mpr",
"Codisjoint",
"Lattice.toSemilatticeSup",
"congrArg",
"Set.Icc.disjoint_iff",
"Iff.rfl",
"PartialOrde... | by
rw [_root_.isCompl_iff, Icc.disjoint_iff, Icc.codisjoint_iff] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Interval.Set.UnorderedInterval | {
"line": 344,
"column": 34
} | {
"line": 344,
"column": 48
} | [
{
"pp": "α : Type u_1\ninst✝ : LinearOrder α\na : α\n⊢ uIoo a a = ∅",
"usedConstants": [
"False",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"congrArg",
"PartialOrder.toPreorder",
"lt_self_iff_false._simp_1",
"min_self",
"SemilatticeInf.toPartialOrder",
... | by simp [uIoo] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Set.Pairwise.Basic | {
"line": 170,
"column": 76
} | {
"line": 170,
"column": 98
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\na b : α\n⊢ {a, b}.Pairwise r ↔ a ≠ b → r a b ∧ r b a",
"usedConstants": [
"congrArg",
"Membership.mem",
"Set.instSingletonSet",
"Insert.insert",
"Ne",
"Set.Pairwise",
"iff_self",
"And",
"Iff",
"Set.instInser... | simp [pairwise_insert] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Set.Pairwise.Basic | {
"line": 170,
"column": 76
} | {
"line": 170,
"column": 98
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\na b : α\n⊢ {a, b}.Pairwise r ↔ a ≠ b → r a b ∧ r b a",
"usedConstants": [
"congrArg",
"Membership.mem",
"Set.instSingletonSet",
"Insert.insert",
"Ne",
"Set.Pairwise",
"iff_self",
"And",
"Iff",
"Set.instInser... | simp [pairwise_insert] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Pairwise.Basic | {
"line": 170,
"column": 76
} | {
"line": 170,
"column": 98
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\na b : α\n⊢ {a, b}.Pairwise r ↔ a ≠ b → r a b ∧ r b a",
"usedConstants": [
"congrArg",
"Membership.mem",
"Set.instSingletonSet",
"Insert.insert",
"Ne",
"Set.Pairwise",
"iff_self",
"And",
"Iff",
"Set.instInser... | simp [pairwise_insert] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Notation.Support | {
"line": 188,
"column": 25
} | {
"line": 188,
"column": 39
} | [
{
"pp": "ι : Type u_1\nκ : Type u_2\nM : Type u_3\ninst✝ : One M\nf : ι × κ → M\ni : ι\nj : κ\nhj : j ∈ mulSupport fun j ↦ f (i, j)\n⊢ (i, j) ∈ mulSupport f ∧ (i, j).2 = j",
"usedConstants": [
"Eq.mpr",
"Function.mem_mulSupport._simp_2",
"and_true",
"congrArg",
"Membership.mem"... | simpa using hj | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Notation.Support | {
"line": 188,
"column": 25
} | {
"line": 188,
"column": 39
} | [
{
"pp": "ι : Type u_1\nκ : Type u_2\nM : Type u_3\ninst✝ : One M\nf : ι × κ → M\ni : ι\nj : κ\nhj : j ∈ mulSupport fun j ↦ f (i, j)\n⊢ (i, j) ∈ mulSupport f ∧ (i, j).2 = j",
"usedConstants": [
"Eq.mpr",
"Function.mem_mulSupport._simp_2",
"and_true",
"congrArg",
"Membership.mem"... | simpa using hj | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Notation.Support | {
"line": 188,
"column": 25
} | {
"line": 188,
"column": 39
} | [
{
"pp": "ι : Type u_1\nκ : Type u_2\nM : Type u_3\ninst✝ : One M\nf : ι × κ → M\ni : ι\nj : κ\nhj : j ∈ mulSupport fun j ↦ f (i, j)\n⊢ (i, j) ∈ mulSupport f ∧ (i, j).2 = j",
"usedConstants": [
"Eq.mpr",
"Function.mem_mulSupport._simp_2",
"and_true",
"congrArg",
"Membership.mem"... | simpa using hj | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 118,
"column": 4
} | {
"line": 118,
"column": 53
} | [
{
"pp": "case inl\nm n : ℕ\nhn : 1 < n\nh : n ! = m !\nhnm : n < m\n⊢ n = m",
"usedConstants": [
"congrArg",
"Eq.mp",
"instOfNatNat",
"Nat.factorial",
"Nat",
"LT.lt",
"propext",
"instLTNat",
"Nat.lt_of_succ_lt",
"Nat.factorial_lt",
"OfNat.ofN... | rw [← factorial_lt <| lt_of_succ_lt hn, h] at hnm | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 122,
"column": 2
} | {
"line": 122,
"column": 51
} | [
{
"pp": "case inr.inr\nm n : ℕ\nhn : 1 < m\nh : n ! = m !\nhnm : m < n\n⊢ n = m",
"usedConstants": [
"congrArg",
"Eq.mp",
"instOfNatNat",
"Nat.factorial",
"Nat",
"LT.lt",
"propext",
"instLTNat",
"Nat.lt_of_succ_lt",
"Nat.factorial_lt",
"OfNat... | rw [← factorial_lt <| lt_of_succ_lt hn, h] at hnm | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 223,
"column": 20
} | {
"line": 223,
"column": 33
} | [
{
"pp": "n k : ℕ\n⊢ n * n.succ.ascFactorial (k + 1) = (n + (k + 1)) * n.ascFactorial (k + 1)",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"Nat.ascFactorial",
"id",
"instMulNat",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Nat.... | ascFactorial, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 223,
"column": 76
} | {
"line": 223,
"column": 89
} | [
{
"pp": "n k : ℕ\n⊢ (n.succ + k) * ((n + k) * n.ascFactorial k) = (n + (k + 1)) * n.ascFactorial (k + 1)",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"Nat.ascFactorial",
"id",
"instMulNat",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",... | ascFactorial, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 276,
"column": 20
} | {
"line": 276,
"column": 33
} | [
{
"pp": "n k : ℕ\n⊢ (n + 1) ^ (k + 1) * (n + 1) < (n + 1).ascFactorial (k + 2)",
"usedConstants": [
"instPowNat",
"Eq.mpr",
"HMul.hMul",
"congrArg",
"Nat.ascFactorial",
"id",
"instMulNat",
"instOfNatNat",
"instNatPowNat",
"instHAdd",
"HPow.hP... | ascFactorial, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 386,
"column": 2
} | {
"line": 389,
"column": 53
} | [
{
"pp": "case pos\nk m n : ℕ\nhkm : k ≤ m\nhmn : m ≤ n\n⊢ (n - k).descFactorial (m - k) * n.descFactorial k = n.descFactorial m",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"HSub.hSub",
"Nat.mul_left_cancel",
"id",
"instSubNat",
"instMulNat",
... | · apply Nat.mul_left_cancel (n - m).factorial_pos
rw [factorial_mul_descFactorial hmn, show n - m = (n - k) - (m - k) by lia, ← Nat.mul_assoc,
factorial_mul_descFactorial (show m - k ≤ n - k by lia),
factorial_mul_descFactorial (le_trans hkm hmn)] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Rat.Cast.Lemmas | {
"line": 55,
"column": 14
} | {
"line": 55,
"column": 30
} | [
{
"pp": "K : Type u_2\ninst✝ : DivisionRing K\nq : ℚ≥0\nhn : (↑q.num / ↑q.den).num = ↑q.num\nhd : (↑q.num / ↑q.den).den = q.den\n⊢ ↑↑q.num / ↑q.den = ↑q.num / ↑q.den",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Int.cast_natCast",
"instH... | Int.cast_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Round | {
"line": 215,
"column": 2
} | {
"line": 215,
"column": 17
} | [
{
"pp": "α : Type u_2\ninst✝³ : Field α\ninst✝² : LinearOrder α\ninst✝¹ : IsStrictOrderedRing α\ninst✝ : FloorRing α\nx : α\n⊢ ↑(round x) ≤ x + 1 / 2",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCom... | rw [round_eq x] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Rat.Floor | {
"line": 133,
"column": 38
} | {
"line": 133,
"column": 54
} | [
{
"pp": "case out\nα : Type u_1\ninst✝³ : Field α\ninst✝² : LinearOrder α\ninst✝¹ : IsStrictOrderedRing α\ninst✝ : FloorRing α\nn d : ℕ\ninv : Invertible ↑d\n⊢ ⌊↑(negOfNat n) / ↑d⌋ = negOfNat ⌈↑↑n / ↑d⌉.toNat",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.cast_natCast",
"instHDiv",
... | Int.cast_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Rat.Floor | {
"line": 385,
"column": 75
} | {
"line": 385,
"column": 91
} | [
{
"pp": "q : ℚ\nq_pos : 0 < q\nq_num_pos : 0 < q.num\nq_num_abs_eq_q_num : ↑q.num.natAbs = q.num\nq_inv : ℚ := ↑q.den / ↑q.num\nq_inv_def : q_inv = ↑q.den / ↑q.num\n⊢ ↑↑q.den / ↑q.num = ↑q.den / ↑q.num",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.cast_natCast",
"Rat.num",
"i... | Int.cast_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 786,
"column": 4
} | {
"line": 786,
"column": 24
} | [
{
"pp": "case inr\nk : Type u_4\ninst✝³ : Field k\ninst✝² : LinearOrder k\ninst✝¹ : IsStrictOrderedRing k\ninst✝ : FloorRing k\na b : k\nhb : 1 < b\nhba✝ : ↑⌈(b - 1)⁻¹⌉ / b < a\nhba : (b - 1)⁻¹ ≤ a\n⊢ ↑⌈a⌉ < b * a",
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"sub_p... | rw [← sub_pos] at hb | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 908,
"column": 39
} | {
"line": 908,
"column": 55
} | [
{
"pp": "R : Type u_2\ninst✝³ : Ring R\ninst✝² : LinearOrder R\ninst✝¹ : IsStrictOrderedRing R\ninst✝ : FloorRing R\na : R\nha : 0 ≤ a\n⊢ ↑⌊a⌋₊ = ↑↑⌊a⌋₊",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.cast_natCast",
"FloorRing.toFloorSemiring",
"congrArg",
"AddGroupWithOn... | Int.cast_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 911,
"column": 37
} | {
"line": 911,
"column": 53
} | [
{
"pp": "R : Type u_2\ninst✝³ : Ring R\ninst✝² : LinearOrder R\ninst✝¹ : IsStrictOrderedRing R\ninst✝ : FloorRing R\na : R\nha : 0 ≤ a\n⊢ ↑⌈a⌉₊ = ↑↑⌈a⌉₊",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.cast_natCast",
"FloorRing.toFloorSemiring",
"congrArg",
"AddGroupWithOn... | Int.cast_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 914,
"column": 51
} | {
"line": 914,
"column": 67
} | [
{
"pp": "R : Type u_2\ninst✝³ : Ring R\ninst✝² : LinearOrder R\ninst✝¹ : IsStrictOrderedRing R\ninst✝ : FloorRing R\na : R\nha : -1 < a\n⊢ ↑⌈a⌉₊ = ↑↑⌈a⌉₊",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.cast_natCast",
"FloorRing.toFloorSemiring",
"congrArg",
"AddGroupWithO... | Int.cast_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Archimedean.Basic | {
"line": 225,
"column": 14
} | {
"line": 225,
"column": 30
} | [
{
"pp": "R : Type u_3\ninst✝³ : Ring R\ninst✝² : PartialOrder R\ninst✝¹ : IsStrictOrderedRing R\ninst✝ : Archimedean R\nx : R\nn : ℕ\nh : x < ↑n\n⊢ x < ↑↑n",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.cast_natCast",
"Preorder.toLT",
"congrArg",
"PartialOrder.toPreorder... | Int.cast_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Archimedean.Basic | {
"line": 266,
"column": 2
} | {
"line": 266,
"column": 7
} | [
{
"pp": "K : Type u_4\ninst✝³ : Semifield K\ninst✝² : LinearOrder K\ninst✝¹ : IsStrictOrderedRing K\ninst✝ : Archimedean K\nε : K\nhε : 0 < ε\nn : ℕ\nhn : 1 / ε < ↑n\n⊢ ∃ n, 1 / (↑n + 1) < ε",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Preorder.toLT",
"instHDiv",
... | use n | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.Algebra.Order.Archimedean.Basic | {
"line": 402,
"column": 40
} | {
"line": 402,
"column": 59
} | [
{
"pp": "G : Type u_1\nM : Type u_2\nR : Type u_3\nK : Type u_4\ninst✝² : Field K\ninst✝¹ : LinearOrder K\ninst✝ : IsStrictOrderedRing K\nq : ℚ\n⊢ q ≤ ↑q",
"usedConstants": [
"Eq.mpr",
"le_refl",
"DivisionRing.toRatCast",
"congrArg",
"Rat",
"PartialOrder.toPreorder",
... | by rw [Rat.cast_id] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Multiset.ZeroCons | {
"line": 117,
"column": 73
} | {
"line": 118,
"column": 86
} | [
{
"pp": "α : Type u_1\np : Multiset α → Prop\nempty : p 0\ncons : ∀ (a : α) (s : Multiset α), p s → p (a ::ₘ s)\n⊢ ∀ (s : Multiset α), p s",
"usedConstants": [
"Quot.ind",
"Multiset",
"List.rec",
"List",
"List.isSetoid",
"Setoid.r",
"Quot.mk"
]
}
] | by
rintro ⟨l⟩; induction l with | nil => exact empty | cons _ _ ih => exact cons _ _ ih | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Multiset.MapFold | {
"line": 482,
"column": 4
} | {
"line": 484,
"column": 87
} | [] | s.map f = s.pmap (fun x _ => f x) fun _ => id := by rw [pmap_eq_map]
_ = s.attach.map fun x => f x.1 := by rw [pmap_eq_map_attach]
_ = t.map g := by rw [this, Multiset.map_map]; exact map_congr rfl fun x _ => h _ _ | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcSteps |
Mathlib.Data.List.Dedup | {
"line": 49,
"column": 64
} | {
"line": 53,
"column": 55
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\na : α\nl : List α\n⊢ a ∈ l.dedup ↔ a ∈ l",
"usedConstants": [
"instDecidableNot",
"List.forall_mem_pwFilter",
"congrArg",
"List.dedup",
"Membership.mem",
"mt",
"Eq.mp",
"id",
"Ne",
"List",
"And",
... | by
have := not_congr (@forall_mem_pwFilter α (· ≠ ·) _ ?_ a l)
· simpa only [dedup, forall_mem_ne, not_not] using this
· intro x y z xz
exact not_and_or.1 <| mt (fun h ↦ h.1.trans h.2) xz | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Dedup | {
"line": 125,
"column": 6
} | {
"line": 125,
"column": 11
} | [
{
"pp": "case cons\nα : Type u_1\ninst✝ : DecidableEq α\nl₂ : List α\na : α\nl₁ : List α\nIH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup\n⊢ (a :: l₁ ++ l₂).dedup = List.insert a (l₁ ∪ l₂.dedup)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.dedup",
"id",
"instBEqOfDecidableEq",
... | ← IH, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Multiset.Filter | {
"line": 342,
"column": 4
} | {
"line": 342,
"column": 58
} | [
{
"pp": "case neg\nα : Type u_1\nβ : Type v\ninst✝¹ : DecidableEq α\ninst✝ : DecidableEq β\nf : α → β\ns : Multiset α\nhf : Injective f\nx : α\nH : ¬x ∈ s\n⊢ count (f x) (map f s) = count x s",
"usedConstants": [
"Eq.mpr",
"Multiset.map",
"congrArg",
"Multiset.mem_map",
"Member... | rw [count_eq_zero_of_notMem H, count_eq_zero, mem_map] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Multiset.UnionInter | {
"line": 246,
"column": 4
} | {
"line": 246,
"column": 38
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nM N P Q : Multiset α\nh : ∀ (a : α), count a (M + N) = count a (P + Q)\nx : α\n⊢ count x M + count x N = count x P + count x Q",
"usedConstants": [
"congrArg",
"Multiset.count",
"Multiset",
"Eq.mp",
"id",
"instHAdd",
"HA... | simp_all only [Multiset.count_add] | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Infix | {
"line": 221,
"column": 23
} | {
"line": 221,
"column": 40
} | [
{
"pp": "α : Type u_1\ns✝ : List α\na : α\nt : List α\nmi : s✝ <+: a :: t\nb : α\ns r : List α\nhr : b :: s ++ r = a :: t\nba : b ≍ a\nst : s ++ r ≍ t\n⊢ ∃ l, l ∈ t.inits ∧ a :: l = b :: s",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Membership.mem",
"Exists",
"id",
"List.... | rw [eq_of_heq ba] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Finset.Insert | {
"line": 359,
"column": 2
} | {
"line": 359,
"column": 37
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\na : α\ns : Finset α\n⊢ (insert a s).val = (a ::ₘ s.val).dedup",
"usedConstants": [
"Eq.mpr",
"Multiset.dedup_cons",
"congrArg",
"Finset.dedup_eq_self",
"Finset",
"Multiset.dedup",
"Multiset",
"Multiset.cons",
... | rw [dedup_cons, dedup_eq_self]; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Insert | {
"line": 359,
"column": 2
} | {
"line": 359,
"column": 37
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\na : α\ns : Finset α\n⊢ (insert a s).val = (a ::ₘ s.val).dedup",
"usedConstants": [
"Eq.mpr",
"Multiset.dedup_cons",
"congrArg",
"Finset.dedup_eq_self",
"Finset",
"Multiset.dedup",
"Multiset",
"Multiset.cons",
... | rw [dedup_cons, dedup_eq_self]; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Fin.Basic | {
"line": 112,
"column": 50
} | {
"line": 112,
"column": 74
} | [
{
"pp": "n : ℕ\ninst✝ : NeZero n\n⊢ Subsingleton (Fin n) ↔ n = 1",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Fin.subsingleton_iff_le_one",
"id",
"instOfNatNat",
"LE.le",
"instLENat",
"Iff",
"Nat",
"propext",
"Subsingleton",
"OfNat.ofNat... | subsingleton_iff_le_one, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.OfFn | {
"line": 144,
"column": 52
} | {
"line": 144,
"column": 66
} | [
{
"pp": "α : Type u\nn : ℕ\nf : Fin n → α\np : α → Bool\nb : α\nx✝ : p b = true ∧ ∃ i, f i = b ∧ ∀ (j : Fin n), j < i → ¬p (f j) = true\nhpb : p b = true\ni : Fin n\nhfb : f i = b\nh : ∀ (j : Fin n), j < i → ¬p (f j) = true\nj : ℕ\nhj : j < ↑i\n⊢ ⟨j, ⋯⟩ < i",
"usedConstants": []
}
] | simpa using hj | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Data.List.OfFn | {
"line": 144,
"column": 52
} | {
"line": 144,
"column": 66
} | [
{
"pp": "α : Type u\nn : ℕ\nf : Fin n → α\np : α → Bool\nb : α\nx✝ : p b = true ∧ ∃ i, f i = b ∧ ∀ (j : Fin n), j < i → ¬p (f j) = true\nhpb : p b = true\ni : Fin n\nhfb : f i = b\nh : ∀ (j : Fin n), j < i → ¬p (f j) = true\nj : ℕ\nhj : j < ↑i\n⊢ ⟨j, ⋯⟩ < i",
"usedConstants": []
}
] | simpa using hj | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.OfFn | {
"line": 144,
"column": 52
} | {
"line": 144,
"column": 66
} | [
{
"pp": "α : Type u\nn : ℕ\nf : Fin n → α\np : α → Bool\nb : α\nx✝ : p b = true ∧ ∃ i, f i = b ∧ ∀ (j : Fin n), j < i → ¬p (f j) = true\nhpb : p b = true\ni : Fin n\nhfb : f i = b\nh : ∀ (j : Fin n), j < i → ¬p (f j) = true\nj : ℕ\nhj : j < ↑i\n⊢ ⟨j, ⋯⟩ < i",
"usedConstants": []
}
] | simpa using hj | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fin.SuccPred | {
"line": 242,
"column": 2
} | {
"line": 242,
"column": 55
} | [
{
"pp": "n : ℕ\nj k : Fin n\n⊢ ↑↑j < ↑↑k ↔ j < k",
"usedConstants": [
"instNeZeroNatHAdd_1",
"congrArg",
"_private.Mathlib.Data.Fin.SuccPred.0.Fin.coe_succ_lt_iff_lt._simp_1_1",
"instOfNatNat",
"Fin.val",
"Fin.coe_eq_castSucc",
"Nat.cast",
"iff_self",
"i... | simp only [coe_eq_castSucc, castSucc_lt_castSucc_iff] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Fin.SuccPred | {
"line": 242,
"column": 2
} | {
"line": 242,
"column": 55
} | [
{
"pp": "n : ℕ\nj k : Fin n\n⊢ ↑↑j < ↑↑k ↔ j < k",
"usedConstants": [
"instNeZeroNatHAdd_1",
"congrArg",
"_private.Mathlib.Data.Fin.SuccPred.0.Fin.coe_succ_lt_iff_lt._simp_1_1",
"instOfNatNat",
"Fin.val",
"Fin.coe_eq_castSucc",
"Nat.cast",
"iff_self",
"i... | simp only [coe_eq_castSucc, castSucc_lt_castSucc_iff] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.SuccPred | {
"line": 242,
"column": 2
} | {
"line": 242,
"column": 55
} | [
{
"pp": "n : ℕ\nj k : Fin n\n⊢ ↑↑j < ↑↑k ↔ j < k",
"usedConstants": [
"instNeZeroNatHAdd_1",
"congrArg",
"_private.Mathlib.Data.Fin.SuccPred.0.Fin.coe_succ_lt_iff_lt._simp_1_1",
"instOfNatNat",
"Fin.val",
"Fin.coe_eq_castSucc",
"Nat.cast",
"iff_self",
"i... | simp only [coe_eq_castSucc, castSucc_lt_castSucc_iff] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fintype.Card | {
"line": 394,
"column": 2
} | {
"line": 394,
"column": 37
} | [
{
"pp": "α : Type u_1\ninst✝² : Fintype α\np : α → Prop\ninst✝¹ : Fintype { a // p a }\ninst✝ : DecidablePred p\n⊢ card { x // p x } = #{x | p x}",
"usedConstants": [
"Finset.univ",
"Fintype.card_of_subtype",
"Finset.filter"
]
}
] | refine Fintype.card_of_subtype _ ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 386,
"column": 2
} | {
"line": 386,
"column": 39
} | [
{
"pp": "α : Sort u_1\nm n : ℕ\nxs : Fin m → α\nys : Fin n → α\ni : Fin (m + n)\n⊢ append xs ys i.rev = append (ys ∘ rev) (xs ∘ rev) (Fin.cast ⋯ i)",
"usedConstants": [
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Fin.rev_surjective"
]
}
] | rcases rev_surjective i with ⟨i, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.List.Duplicate | {
"line": 96,
"column": 19
} | {
"line": 96,
"column": 49
} | [
{
"pp": "case cons\nα : Type u_1\nl : List α\nx : α\nl' l₁✝ l₂✝ : List α\ny : α\na✝ : l₁✝ <+ l₂✝\nIH : x ∈+ l₁✝ → x ∈+ l₂✝\nhx : x ∈+ l₁✝\n⊢ x ∈+ y :: l₂✝",
"usedConstants": [
"List.Duplicate.duplicate_cons"
]
}
] | exact (IH hx).duplicate_cons _ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.List.Duplicate | {
"line": 96,
"column": 19
} | {
"line": 96,
"column": 49
} | [
{
"pp": "case cons\nα : Type u_1\nl : List α\nx : α\nl' l₁✝ l₂✝ : List α\ny : α\na✝ : l₁✝ <+ l₂✝\nIH : x ∈+ l₁✝ → x ∈+ l₂✝\nhx : x ∈+ l₁✝\n⊢ x ∈+ y :: l₂✝",
"usedConstants": [
"List.Duplicate.duplicate_cons"
]
}
] | exact (IH hx).duplicate_cons _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Duplicate | {
"line": 96,
"column": 19
} | {
"line": 96,
"column": 49
} | [
{
"pp": "case cons\nα : Type u_1\nl : List α\nx : α\nl' l₁✝ l₂✝ : List α\ny : α\na✝ : l₁✝ <+ l₂✝\nIH : x ∈+ l₁✝ → x ∈+ l₂✝\nhx : x ∈+ l₁✝\n⊢ x ∈+ y :: l₂✝",
"usedConstants": [
"List.Duplicate.duplicate_cons"
]
}
] | exact (IH hx).duplicate_cons _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Card | {
"line": 757,
"column": 2
} | {
"line": 760,
"column": 9
} | [
{
"pp": "α : Type u_1\ns : Finset α\ninst✝ : DecidableEq α\n⊢ #s = 2 ↔ ∃ x y, x ≠ y ∧ s = {x, y}",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"Membership.mem",
"Exists",
"id",
"Insert.insert",
"Ne",
"instOfNatNat",
"Finset.instInsert",
... | constructor
· rw [card_eq_succ]
grind [card_eq_one]
· grind | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Card | {
"line": 757,
"column": 2
} | {
"line": 760,
"column": 9
} | [
{
"pp": "α : Type u_1\ns : Finset α\ninst✝ : DecidableEq α\n⊢ #s = 2 ↔ ∃ x y, x ≠ y ∧ s = {x, y}",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"Membership.mem",
"Exists",
"id",
"Insert.insert",
"Ne",
"instOfNatNat",
"Finset.instInsert",
... | constructor
· rw [card_eq_succ]
grind [card_eq_one]
· grind | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fintype.EquivFin | {
"line": 211,
"column": 62
} | {
"line": 217,
"column": 34
} | [
{
"pp": "α : Type u_1\ninst✝ : Fintype α\n⊢ card α = 1 ↔ ∃ x, ∀ (y : α), y = x",
"usedConstants": [
"Eq.mpr",
"Unit.unit",
"Equiv.instEquivLike",
"congrArg",
"Exists",
"Equiv.mk",
"Fintype.card_eq",
"Fintype.card",
"id",
"Equiv",
"instOfNatNa... | by
rw [← card_unit, card_eq]
exact
⟨fun ⟨a⟩ => ⟨a.symm (), fun y => a.injective (Subsingleton.elim _ _)⟩,
fun ⟨x, hx⟩ =>
⟨⟨fun _ => (), fun _ => x, fun _ => (hx _).trans (hx _).symm, fun _ =>
Subsingleton.elim _ _⟩⟩⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Fintype.EquivFin | {
"line": 350,
"column": 52
} | {
"line": 352,
"column": 5
} | [
{
"pp": "α : Type u_1\ninst✝ : Finite α\ne : α ↪ α\n⊢ e.equivOfFiniteSelfEmbedding.toEmbedding = e",
"usedConstants": [
"Function.Embedding",
"Equiv.toEmbedding",
"Function.Embedding.ext",
"Eq.refl",
"Function.instFunLikeEmbedding",
"DFunLike.coe",
"Function.Embeddi... | by
ext
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Fintype.EquivFin | {
"line": 538,
"column": 46
} | {
"line": 549,
"column": 25
} | [
{
"pp": "α : Type u_4\ninst✝ : Infinite α\n⊢ Injective (natEmbeddingAux α)",
"usedConstants": [
"Multiset.toFinset",
"Iff.mpr",
"Eq.mpr",
"_private.Mathlib.Data.Fintype.EquivFin.0.Infinite.natEmbeddingAux",
"congrArg",
"_private.Mathlib.Data.Fintype.EquivFin.0.Infinite.na... | by
rintro m n h
letI := Classical.decEq α
wlog hmlen : m ≤ n generalizing m n
· exact (this h.symm <| le_of_not_ge hmlen).symm
by_contra hmn
have hmn : m < n := lt_of_le_of_ne hmlen hmn
refine (Classical.choose_spec (exists_notMem_finset
((Multiset.range n).pmap (fun m (_ : m < n) ↦ natEmbeddingAux α ... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1051,
"column": 39
} | {
"line": 1051,
"column": 50
} | [
{
"pp": "n : ℕ\nα : Fin (n + 1) → Type u_3\n⊢ (insertNthEquiv α 0).symm = (consEquiv α).symm",
"usedConstants": [
"Fin.succAbove",
"instNeZeroNatHAdd_1",
"Equiv.instEquivLike",
"Fin.instOfNat",
"Equiv",
"Equiv.ext",
"instOfNatNat",
"Prod.fst",
"funext",
... | ext <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1051,
"column": 39
} | {
"line": 1051,
"column": 50
} | [
{
"pp": "n : ℕ\nα : Fin (n + 1) → Type u_3\n⊢ (insertNthEquiv α 0).symm = (consEquiv α).symm",
"usedConstants": [
"Fin.succAbove",
"instNeZeroNatHAdd_1",
"Equiv.instEquivLike",
"Fin.instOfNat",
"Equiv",
"Equiv.ext",
"instOfNatNat",
"Prod.fst",
"funext",
... | ext <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1051,
"column": 39
} | {
"line": 1051,
"column": 50
} | [
{
"pp": "n : ℕ\nα : Fin (n + 1) → Type u_3\n⊢ (insertNthEquiv α 0).symm = (consEquiv α).symm",
"usedConstants": [
"Fin.succAbove",
"instNeZeroNatHAdd_1",
"Equiv.instEquivLike",
"Fin.instOfNat",
"Equiv",
"Equiv.ext",
"instOfNatNat",
"Prod.fst",
"funext",
... | ext <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1241,
"column": 2
} | {
"line": 1241,
"column": 70
} | [
{
"pp": "n : ℕ\np : Fin n → Bool\nh : (find? p).isSome = true\n⊢ find? p = some (Fin.find (fun x ↦ p x = true) ⋯)",
"usedConstants": [
"Eq.mpr",
"dite_congr",
"instDecidableTrue",
"Fin.find?_eq_dite",
"congrArg",
"Option.some",
"Exists",
"id",
"instDecid... | simp_rw [find?_eq_dite, exists_eq_true_of_isSome_find? h, dite_true] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1241,
"column": 2
} | {
"line": 1241,
"column": 70
} | [
{
"pp": "n : ℕ\np : Fin n → Bool\nh : (find? p).isSome = true\n⊢ find? p = some (Fin.find (fun x ↦ p x = true) ⋯)",
"usedConstants": [
"Eq.mpr",
"dite_congr",
"instDecidableTrue",
"Fin.find?_eq_dite",
"congrArg",
"Option.some",
"Exists",
"id",
"instDecid... | simp_rw [find?_eq_dite, exists_eq_true_of_isSome_find? h, dite_true] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1241,
"column": 2
} | {
"line": 1241,
"column": 70
} | [
{
"pp": "n : ℕ\np : Fin n → Bool\nh : (find? p).isSome = true\n⊢ find? p = some (Fin.find (fun x ↦ p x = true) ⋯)",
"usedConstants": [
"Eq.mpr",
"dite_congr",
"instDecidableTrue",
"Fin.find?_eq_dite",
"congrArg",
"Option.some",
"Exists",
"id",
"instDecid... | simp_rw [find?_eq_dite, exists_eq_true_of_isSome_find? h, dite_true] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Fold | {
"line": 120,
"column": 4
} | {
"line": 120,
"column": 70
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type u_2\nγ : Type u_3\nop : β → β → β\nhc : Std.Commutative op\nha : Std.Associative op\nf : α → β\nb : β\ninst✝ : DecidableEq α\ng : γ → α\nhi : Std.IdempotentOp op\nx : γ\nxs : Finset γ\nhx : x ∉ xs\nih : fold op b f (image g xs) = fold op b (f ∘ g) xs\nthis : DecidableE... | rw [fold_cons, cons_eq_insert, image_insert, fold_insert_idem, ih] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Finset.Fold | {
"line": 150,
"column": 66
} | {
"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... | by
classical
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 | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Sort | {
"line": 163,
"column": 2
} | {
"line": 163,
"column": 14
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ninst✝² : DecidableRel r\ninst✝¹ : DecidableEq α\ninst✝ : Std.Refl r\nx : α\nxs : List α\n⊢ (orderedInsert r x xs).erase x = xs",
"usedConstants": [
"List.orderedInsert",
"List.rec",
"instBEqOfDecidableEq",
"List",
"List.erase",
"Eq... | induction xs | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.List.Sort | {
"line": 169,
"column": 2
} | {
"line": 169,
"column": 14
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ninst✝¹ : DecidableRel r\ninst✝ : DecidableEq α\nx : α\nxs : List α\nhx : ¬x ∈ xs\n⊢ (orderedInsert r x xs).erase x = xs",
"usedConstants": [
"Membership.mem",
"List.orderedInsert",
"List.rec",
"instBEqOfDecidableEq",
"List",
"List.... | induction xs | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.List.Sort | {
"line": 178,
"column": 2
} | {
"line": 178,
"column": 14
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ninst✝ : DecidableRel r\nx : α\nxs : List α\n⊢ xs <+ orderedInsert r x xs",
"usedConstants": [
"List.orderedInsert",
"List.rec",
"List",
"List.Sublist"
]
}
] | induction xs | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.List.Range | {
"line": 81,
"column": 6
} | {
"line": 85,
"column": 42
} | [
{
"pp": "case cons.right\na : ℕ\nl : List ℕ\nhl : Pairwise Disjoint l.ranges\n⊢ Pairwise Disjoint (map (map fun x ↦ a + x) l.ranges)",
"usedConstants": [
"Eq.mpr",
"List.Pairwise",
"congrArg",
"List.map",
"id",
"List.pairwise_map",
"List.Disjoint",
"List",
... | rw [pairwise_map]
apply Pairwise.imp _ hl
intro u v
apply disjoint_map
exact fun u v => Nat.add_left_cancel | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Range | {
"line": 81,
"column": 6
} | {
"line": 85,
"column": 42
} | [
{
"pp": "case cons.right\na : ℕ\nl : List ℕ\nhl : Pairwise Disjoint l.ranges\n⊢ Pairwise Disjoint (map (map fun x ↦ a + x) l.ranges)",
"usedConstants": [
"Eq.mpr",
"List.Pairwise",
"congrArg",
"List.map",
"id",
"List.pairwise_map",
"List.Disjoint",
"List",
... | rw [pairwise_map]
apply Pairwise.imp _ hl
intro u v
apply disjoint_map
exact fun u v => Nat.add_left_cancel | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Rotate | {
"line": 210,
"column": 6
} | {
"line": 212,
"column": 36
} | [
{
"pp": "case inr.e_a\nα : Type u\nl : List α\nn m : ℕ\nhml : m < l.length\nhm : l.length - n % l.length ≤ m\nhlt : n % l.length < l.length\nhm' : l.length ≤ n % l.length + m\n⊢ m - (l.length - n % l.length) = (m + n) % l.length",
"usedConstants": [
"Eq.mpr",
"congrArg",
"HSub.hSub",
... | have : n % length l + m - length l < length l := by
rw [Nat.sub_lt_iff_lt_add hm']
exact Nat.add_lt_add hlt hml | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 167,
"column": 6
} | {
"line": 167,
"column": 17
} | [
{
"pp": "M : Type u_4\ninst✝ : CommMonoid M\nl₁ l₂ : List M\nh : l₁ <+ l₂\nl : List M\nhl : l₂ ~ l₁ ++ l\n⊢ l₁.prod ∣ l₂.prod",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Dvd.dvd",
"Monoid.toMulOneClass",
"congrArg",
"List.Perm.prod_eq",
"semigroupDvd",
"id... | hl.prod_eq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Rotate | {
"line": 458,
"column": 31
} | {
"line": 458,
"column": 48
} | [
{
"pp": "α : Type u\nl l' : List α\n⊢ l ~r l' ↔ ∃ a, a < l.length + 1 ∧ l.rotate a = l'",
"usedConstants": [
"Eq.mpr",
"congrArg",
"_private.Mathlib.Data.List.Rotate.0.List.isRotated_iff_mem_map_range._simp_1_3",
"Exists",
"id",
"instOfNatNat",
"LE.le",
"instL... | isRotated_iff_mod | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.List.Rotate | {
"line": 467,
"column": 2
} | {
"line": 467,
"column": 7
} | [
{
"pp": "α : Type u\nβ : Type u_1\nl₁ : List α\nf : α → β\nn : ℕ\n⊢ List.map f l₁ ~r (List.map f l₁).rotate n",
"usedConstants": [
"List.map",
"List",
"Nat",
"Exists.intro",
"Eq.refl",
"Eq",
"List.rotate"
]
}
] | use n | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.Algebra.BigOperators.Group.Multiset.Basic | {
"line": 45,
"column": 55
} | {
"line": 47,
"column": 43
} | [
{
"pp": "ι : Type u_2\nM : Type u_5\ninst✝¹ : CommMonoid M\nm : Multiset ι\nf : ι → M\ninst✝ : DecidableEq ι\na : ι\nh : a ∈ m\n⊢ f a * (map f (m.erase a)).prod = (map f m).prod",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"MulOne.toOne",
"Multiset.coe_toList",
"HMul.hMul",
... | by
rw [← m.coe_toList, coe_erase, map_coe, map_coe, prod_coe, prod_coe,
List.prod_map_erase f (mem_toList.2 h)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.BigOperators.Group.Multiset.Basic | {
"line": 58,
"column": 16
} | {
"line": 58,
"column": 85
} | [
{
"pp": "M : Type u_5\ninst✝ : CommMonoid M\nm : Multiset M\nn : ℕ\n⊢ ((n + 1) • m).prod = m.prod ^ (n + 1)",
"usedConstants": [
"Eq.mpr",
"instHSMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"AddMonoid.toAddZeroClass",
"Multiset.prod",
"AddMonoid.toN... | rw [add_nsmul, one_nsmul, pow_add, pow_one, prod_add, prod_nsmul m n] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.BigOperators.Group.Multiset.Basic | {
"line": 58,
"column": 16
} | {
"line": 58,
"column": 85
} | [
{
"pp": "M : Type u_5\ninst✝ : CommMonoid M\nm : Multiset M\nn : ℕ\n⊢ ((n + 1) • m).prod = m.prod ^ (n + 1)",
"usedConstants": [
"Eq.mpr",
"instHSMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"AddMonoid.toAddZeroClass",
"Multiset.prod",
"AddMonoid.toN... | rw [add_nsmul, one_nsmul, pow_add, pow_one, prod_add, prod_nsmul m n] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.Multiset.Basic | {
"line": 58,
"column": 16
} | {
"line": 58,
"column": 85
} | [
{
"pp": "M : Type u_5\ninst✝ : CommMonoid M\nm : Multiset M\nn : ℕ\n⊢ ((n + 1) • m).prod = m.prod ^ (n + 1)",
"usedConstants": [
"Eq.mpr",
"instHSMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"AddMonoid.toAddZeroClass",
"Multiset.prod",
"AddMonoid.toN... | rw [add_nsmul, one_nsmul, pow_add, pow_one, prod_add, prod_nsmul m n] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.OffDiag | {
"line": 38,
"column": 68
} | {
"line": 43,
"column": 55
} | [
{
"pp": "α : Type u_1\na : α\nl : List α\n⊢ (a :: l).offDiag ~ map (fun x ↦ (a, x)) l ++ map (fun x ↦ (x, a)) l ++ l.offDiag",
"usedConstants": [
"Eq.mpr",
"List.eraseIdx",
"List.Perm.refl._simp_1",
"List.append_assoc",
"_private.Mathlib.Data.List.OffDiag.0.List.offDiag_cons_pe... | by
simp only [offDiag, zipIdx_cons']
have : map (fun x ↦ (x.fst, a)) l.zipIdx = map (·, a) l := by
conv_rhs => rw [← zipIdx_map_fst 0 l, map_map, Function.comp_def]
simp [append_assoc, perm_append_left_iff, flatMap_map,
← (map_append_flatMap_perm _ _ _).congr_left, this] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.OffDiag | {
"line": 116,
"column": 2
} | {
"line": 116,
"column": 56
} | [
{
"pp": "α : Type u_1\nl : List α\nh : l.Nodup\nx y : α\n⊢ (x, y) ∈ l.offDiag ↔ (x, y).fst ∈ l ∧ (x, y).snd ∈ l ∧ (x, y).fst ≠ (x, y).snd",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Iff.of_eq",
"_private.Mathlib.Data.List.OffDiag.0.List.Nodup.mem_offDiag._simp_1_2",
"congrArg",
... | simp_rw [mem_offDiag_iff_getElem, mem_iff_getElem, Ne] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Data.Fintype.Pi | {
"line": 101,
"column": 2
} | {
"line": 101,
"column": 71
} | [
{
"pp": "α : Type u_1\ninst✝² : DecidableEq α\ninst✝¹ : Fintype α\nδ : α → Type u_4\nt : (a : α) → Finset (δ a)\na : α\ninst✝ : DecidableEq (δ a)\nx : δ a\nh : x ∈ t a\nf : (b : α) → a ≠ b → δ b\nhf : ∀ (b : α) (a : a ≠ b), f b a ∈ t b\n⊢ ∃ a_1 ∈ piFinset t, a_1 a = x",
"usedConstants": [
"dite_cond_e... | exact ⟨fun b ↦ if h : a = b then h ▸ x else f _ h, by aesop, by simp⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Group.Pointwise.Set.Lattice | {
"line": 279,
"column": 25
} | {
"line": 279,
"column": 41
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝ : SMul α β\na : α\nS : Set (Set β)\n⊢ a • ⋃ i ∈ S, i = ⋃ s ∈ S, a • s",
"usedConstants": [
"Set.smul_set_iUnion₂",
"Eq.mpr",
"instHSMul",
"congrArg",
"Membership.mem",
"id",
"HSMul.hSMul",
"Eq",
"Set.instMembers... | smul_set_iUnion₂ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Pi.Lemmas | {
"line": 286,
"column": 2
} | {
"line": 287,
"column": 29
} | [
{
"pp": "I : Type u\nf : I → Type v\ninst✝¹ : DecidableEq I\ninst✝ : (i : I) → MulOneClass (f i)\n⊢ Pairwise fun i j ↦ ∀ (x : f i) (y : f j), Commute (mulSingle i x) (mulSingle j y)",
"usedConstants": [
"MulOne.toOne",
"False",
"HMul.hMul",
"eq_false",
"congrArg",
"Eq.mp"... | intro i j hij x y; ext k
by_cases i = k <;> simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Pi.Lemmas | {
"line": 286,
"column": 2
} | {
"line": 287,
"column": 29
} | [
{
"pp": "I : Type u\nf : I → Type v\ninst✝¹ : DecidableEq I\ninst✝ : (i : I) → MulOneClass (f i)\n⊢ Pairwise fun i j ↦ ∀ (x : f i) (y : f j), Commute (mulSingle i x) (mulSingle j y)",
"usedConstants": [
"MulOne.toOne",
"False",
"HMul.hMul",
"eq_false",
"congrArg",
"Eq.mp"... | intro i j hij x y; ext k
by_cases i = k <;> simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Pointwise.Set.Basic | {
"line": 753,
"column": 19
} | {
"line": 753,
"column": 72
} | [
{
"pp": "α : Type u_2\ninst✝ : CancelMonoid α\ns : Set α\nhs : s.Nontrivial\nn : ℕ\nx✝ : n + 2 ≠ 0\n⊢ (s ^ (n + 2)).Nontrivial",
"usedConstants": [
"Eq.mpr",
"Set.Nontrivial.mul",
"CancelMonoid.toRightCancelMonoid",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"... | simpa [pow_succ] using (hs.pow n.succ_ne_zero).mul hs | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Group.Pointwise.Set.Basic | {
"line": 753,
"column": 19
} | {
"line": 753,
"column": 72
} | [
{
"pp": "α : Type u_2\ninst✝ : CancelMonoid α\ns : Set α\nhs : s.Nontrivial\nn : ℕ\nx✝ : n + 2 ≠ 0\n⊢ (s ^ (n + 2)).Nontrivial",
"usedConstants": [
"Eq.mpr",
"Set.Nontrivial.mul",
"CancelMonoid.toRightCancelMonoid",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"... | simpa [pow_succ] using (hs.pow n.succ_ne_zero).mul hs | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Pointwise.Set.Basic | {
"line": 753,
"column": 19
} | {
"line": 753,
"column": 72
} | [
{
"pp": "α : Type u_2\ninst✝ : CancelMonoid α\ns : Set α\nhs : s.Nontrivial\nn : ℕ\nx✝ : n + 2 ≠ 0\n⊢ (s ^ (n + 2)).Nontrivial",
"usedConstants": [
"Eq.mpr",
"Set.Nontrivial.mul",
"CancelMonoid.toRightCancelMonoid",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"... | simpa [pow_succ] using (hs.pow n.succ_ne_zero).mul hs | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.Lattice.Image | {
"line": 419,
"column": 26
} | {
"line": 419,
"column": 46
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nf : α → β\ns : Set β\n⊢ f ⁻¹' ⋃ i ∈ s, {i} = f ⁻¹' s",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Membership.mem",
"Set.biUnion_of_singleton",
"Set.instSingletonSet",
"id",
"Set.preimage",
"Singleton.singleton",
"Eq",
... | biUnion_of_singleton | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Subgroup.Lattice | {
"line": 627,
"column": 6
} | {
"line": 628,
"column": 95
} | [
{
"pp": "case mp.refine_3\nG : Type u_1\ninst✝ : Group G\ns t : Subgroup G\nht : t.Normal\nx : G\nhx : x ∈ closure (↑s ∪ ↑t)\ny₁ : G\nhy₁ : y₁ ∈ s\nz₁ : G\nhz₁ : z₁ ∈ t\nhx✝ : y₁ * z₁ ∈ closure (↑s ∪ ↑t)\ny₂ : G\nhy₂ : y₂ ∈ s\nz₂ : G\nhz₂ : z₂ ∈ t\nhy✝ : y₂ * z₂ ∈ closure (↑s ∪ ↑t)\n⊢ ∃ y ∈ s, ∃ z ∈ t, y * z = ... | exact ⟨y₁ * y₂, s.mul_mem hy₁ hy₂,
(y₂⁻¹ * z₁ * y₂) * z₂, t.mul_mem (ht.conj_mem' z₁ hz₁ y₂) hz₂, by simp [mul_assoc]⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Group.Subgroup.Map | {
"line": 95,
"column": 68
} | {
"line": 97,
"column": 5
} | [
{
"pp": "N : Type u_5\ninst✝ : Group N\nK : Subgroup N\n⊢ comap (MonoidHom.id N) K = K",
"usedConstants": [
"Monoid.toMulOneClass",
"Iff.rfl",
"Membership.mem",
"DivInvMonoid.toMonoid",
"Subgroup",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"MonoidHom.id"... | by
ext
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Subgroup.Map | {
"line": 589,
"column": 85
} | {
"line": 591,
"column": 5
} | [
{
"pp": "G : Type u_1\nG' : Type u_2\ninst✝¹ : Group G\ninst✝ : Group G'\nH : Subgroup G\ne : G ≃* G'\n⊢ H.equivMapOfInjective ↑e ⋯ = e.subgroupMap H",
"usedConstants": [
"MulEquiv.instEquivLike",
"Subgroup.map",
"Monoid.toMulOneClass",
"MulEquiv.instMulEquivClass",
"Subgroup.m... | by
ext
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Submonoid.Operations | {
"line": 1105,
"column": 85
} | {
"line": 1107,
"column": 5
} | [
{
"pp": "M : Type u_1\nN : Type u_2\ninst✝¹ : MulOneClass M\ninst✝ : MulOneClass N\nS : Submonoid M\ne : M ≃* N\n⊢ S.equivMapOfInjective ↑e ⋯ = e.submonoidMap S",
"usedConstants": [
"MonoidHom.instMonoidHomClass",
"MulEquiv.instEquivLike",
"MonoidHom.instFunLike",
"Submonoid.mul",
... | by
ext
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Pairing | {
"line": 64,
"column": 4
} | {
"line": 64,
"column": 97
} | [
{
"pp": "case pos\na b : ℕ\nh : a < b\n⊢ unpair (b * b + a) = (a, b)",
"usedConstants": [
"HMul.hMul",
"le_of_lt",
"Nat.le_add_left",
"instMulNat",
"Nat.sqrt",
"instHAdd",
"HAdd.hAdd",
"Nat.instPreorder",
"Nat",
"instAddNat",
"Eq",
"Nat... | have be : sqrt (b * b + a) = b := sqrt_add_eq _ (le_trans (le_of_lt h) (Nat.le_add_left _ _)) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Nat.Pairing | {
"line": 84,
"column": 61
} | {
"line": 91,
"column": 62
} | [
{
"pp": "n : ℕ\nn1 : 1 ≤ n\n⊢ (unpair n).1 < n",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"lt_of_le_of_lt",
"HMul.hMul",
"eq_false",
"congrArg",
"Nat.unpair",
"_private.Mathlib.Data.Nat.Pairing.0.Nat.unpair_lt._simp_1_3",
"PartialOrder.toPreorder",
... | by
let s := sqrt n
simp only [unpair]
by_cases h : n - s * s < s <;> simp only [h, ↓reduceIte, gt_iff_lt, s]
· exact lt_of_lt_of_le h (sqrt_le_self _)
· simp only [not_lt] at h
have s0 : 0 < s := sqrt_pos.2 n1
exact lt_of_le_of_lt h (Nat.sub_lt n1 (Nat.mul_pos s0 s0)) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Logic.Encodable.Basic | {
"line": 572,
"column": 2
} | {
"line": 572,
"column": 40
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Encodable α\ninst✝ : Inhabited α\nr : β → β → Prop\nf : α → β\nhf : Directed r f\na : α\n⊢ r (f a) (f (Directed.sequence f hf (encode a + 1)))",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Option.some",
"id",
"instOfNatNat",
"in... | simp only [Directed.sequence, encodek] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.FreeMonoid.Basic | {
"line": 131,
"column": 2
} | {
"line": 131,
"column": 14
} | [
{
"pp": "α : Type u_1\nxs : List (FreeMonoid α)\n⊢ toList xs.prod = (List.map (⇑toList) xs).flatten",
"usedConstants": [
"MulOne.toOne",
"CancelMonoid.toRightCancelMonoid",
"FreeMonoid",
"Equiv.instEquivLike",
"Monoid.toMulOneClass",
"List.map",
"FreeMonoid.instCanc... | induction xs | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Nat.Choose.Basic | {
"line": 105,
"column": 26
} | {
"line": 105,
"column": 43
} | [
{
"pp": "n : ℕ\n⊢ (n + 1) * (n + 1 - 1) / 2 = (n * (n - 1) + 2 * n) / 2",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"congrArg",
"HSub.hSub",
"id",
"HDiv.hDiv",
"instSubNat",
"instMulNat",
"instOfNatNat",
"Nat.mul_comm",
"ins... | Nat.mul_comm 2 n, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Sublists | {
"line": 334,
"column": 28
} | {
"line": 334,
"column": 61
} | [
{
"pp": "α : Type u\nn : ℕ\nl : List α\nh✝ : l.Nodup\na✝ b✝ : List α\nh : Lex (swap fun x1 x2 ↦ x1 ≠ x2) a✝ b✝\n⊢ Lex (fun x1 x2 ↦ x1 ≠ x2) a✝ b✝",
"usedConstants": [
"Eq.mpr",
"congrArg",
"HEq.refl",
"Function.swap",
"Eq.casesOn",
"Ne",
"funext",
"List",
... | convert h using 3; simp [eq_comm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sublists | {
"line": 334,
"column": 28
} | {
"line": 334,
"column": 61
} | [
{
"pp": "α : Type u\nn : ℕ\nl : List α\nh✝ : l.Nodup\na✝ b✝ : List α\nh : Lex (swap fun x1 x2 ↦ x1 ≠ x2) a✝ b✝\n⊢ Lex (fun x1 x2 ↦ x1 ≠ x2) a✝ b✝",
"usedConstants": [
"Eq.mpr",
"congrArg",
"HEq.refl",
"Function.swap",
"Eq.casesOn",
"Ne",
"funext",
"List",
... | convert h using 3; simp [eq_comm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Choose.Basic | {
"line": 318,
"column": 2
} | {
"line": 322,
"column": 92
} | [
{
"pp": "r n : ℕ\nh : r < n / 2\n⊢ n.choose r ≤ n.choose (r + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"instHDiv",
"Nat.lt_sub_iff_add_lt",
"HMul.hMul",
"Nat.div_mul_le_self",
"congrArg",
"Nat.sub_pos_of_lt",
"Nat.mul_lt_mul_of_pos_right",
"... | refine Nat.le_of_mul_le_mul_right ?_ (Nat.sub_pos_of_lt (h.trans_le (n.div_le_self 2)))
rw [← choose_succ_right_eq]
apply Nat.mul_le_mul_left
rw [← Nat.lt_iff_add_one_le, Nat.lt_sub_iff_add_lt, ← Nat.mul_two]
exact lt_of_lt_of_le (Nat.mul_lt_mul_of_pos_right h Nat.zero_lt_two) (n.div_mul_le_self 2) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.