module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.Algebra.BigOperators.Group.List.Basic | {
"line": 338,
"column": 64
} | {
"line": 341,
"column": 61
} | [
{
"pp": "G : Type u_7\ninst✝ : Group G\nn : ℕ\nf : ℕ → G\n⊢ (map (fun k ↦ f k / f (k + 1)) (range n)).prod = f 0 / f n",
"usedConstants": [
"MulOne.toOne",
"Nat.recAux",
"instHDiv",
"InvOneClass.toOne",
"List.prod_append",
"HMul.hMul",
"Semigroup.to_isAssociative",
... | by
induction n with
| zero => exact (div_self' (f 0)).symm
| succ n h => simp [range_succ, prod_append, map_append, h] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Basic | {
"line": 621,
"column": 30
} | {
"line": 621,
"column": 35
} | [
{
"pp": "α : Type u\nl : List α\nn : ℕ\nh : n < l.length\n⊢ take 1 (l[n] :: drop (n + 1) l) = [l.get ⟨n, h⟩]",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.take.eq_3",
"List.get",
"Fin.mk",
"id",
"instOfNatNat",
"List.cons",
"GetElem.getElem",
"L... | take, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Defs | {
"line": 209,
"column": 4
} | {
"line": 210,
"column": 7
} | [
{
"pp": "case succ\nm k : ℕ+\nn : ℕ\n⊢ ↑(k.modDivAux (n + 1) (↑m / ↑k)).fst = if n + 1 = 0 then ↑k else n + 1",
"usedConstants": [
"PNat.val",
"Eq.mpr",
"instHDiv",
"congrArg",
"id",
"HDiv.hDiv",
"instOfNatNat",
"Prod.fst",
"instHAdd",
"Nat.succ_ne... | rw [if_neg n.succ_ne_zero]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PNat.Defs | {
"line": 209,
"column": 4
} | {
"line": 210,
"column": 7
} | [
{
"pp": "case succ\nm k : ℕ+\nn : ℕ\n⊢ ↑(k.modDivAux (n + 1) (↑m / ↑k)).fst = if n + 1 = 0 then ↑k else n + 1",
"usedConstants": [
"PNat.val",
"Eq.mpr",
"instHDiv",
"congrArg",
"id",
"HDiv.hDiv",
"instOfNatNat",
"Prod.fst",
"instHAdd",
"Nat.succ_ne... | rw [if_neg n.succ_ne_zero]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.PNat.Defs | {
"line": 220,
"column": 4
} | {
"line": 221,
"column": 7
} | [
{
"pp": "case succ\nm k : ℕ+\nn : ℕ\n⊢ (k.modDivAux (n + 1) (↑m / ↑k)).snd = if n + 1 = 0 then ↑m / ↑k - 1 else ↑m / ↑k",
"usedConstants": [
"PNat.val",
"Eq.mpr",
"instHDiv",
"congrArg",
"HSub.hSub",
"id",
"HDiv.hDiv",
"instSubNat",
"instOfNatNat",
... | rw [if_neg n.succ_ne_zero]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PNat.Defs | {
"line": 220,
"column": 4
} | {
"line": 221,
"column": 7
} | [
{
"pp": "case succ\nm k : ℕ+\nn : ℕ\n⊢ (k.modDivAux (n + 1) (↑m / ↑k)).snd = if n + 1 = 0 then ↑m / ↑k - 1 else ↑m / ↑k",
"usedConstants": [
"PNat.val",
"Eq.mpr",
"instHDiv",
"congrArg",
"HSub.hSub",
"id",
"HDiv.hDiv",
"instSubNat",
"instOfNatNat",
... | rw [if_neg n.succ_ne_zero]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Rat.Lemmas | {
"line": 144,
"column": 6
} | {
"line": 144,
"column": 13
} | [
{
"pp": "q₁ q₂ : ℚ\n⊢ q₁.num * q₂.num = (q₁ * q₂).num * ↑((q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den))",
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
"Int.instDiv",
"Rat.instMul",
"Rat.num",
"instHDiv",
"HMul.hMul",
"congrArg",
"Rat",
"Rat.den",
... | mul_num | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Rat.Cast.Defs | {
"line": 169,
"column": 6
} | {
"line": 169,
"column": 15
} | [
{
"pp": "α : Type u_3\ninst✝ : DivisionRing α\nq r : ℚ\nhq : ↑q.den ≠ 0\nhr : ↑r.den ≠ 0\n⊢ ↑(q + r) = ↑q + ↑r",
"usedConstants": [
"Eq.mpr",
"Rat.add_def'",
"Rat.num",
"HMul.hMul",
"DivisionRing.toRatCast",
"congrArg",
"Rat",
"Rat.den",
"DivisionRing.to... | add_def', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.CompleteLattice.Lemmas | {
"line": 54,
"column": 12
} | {
"line": 54,
"column": 26
} | [
{
"pp": "α : Type u_1\ninst✝ : CompleteLattice α\nf : Bool → α\n⊢ sSup (range fun b ↦ f b) = f true ⊔ f false",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"congrArg",
"SemilatticeSup.toMax",
"Set.instSingletonSet",
"id",
... | Bool.range_eq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.GaloisConnection.Basic | {
"line": 106,
"column": 8
} | {
"line": 106,
"column": 76
} | [
{
"pp": "α : Type u\nβ : Type v\nι : Sort x\ninst✝¹ : CompleteLattice α\ninst✝ : CompleteLattice β\nl : α → β\nu : β → α\ngc : GaloisConnection l u\nf : ι → α\n⊢ IsLUB (range (l ∘ f)) (l (iSup f))",
"usedConstants": [
"Set.range_comp",
"Eq.mpr",
"GaloisConnection.isLUB_l_image",
"con... | rw [range_comp, ← sSup_range]; exact gc.isLUB_l_image (isLUB_sSup _) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.GaloisConnection.Basic | {
"line": 106,
"column": 8
} | {
"line": 106,
"column": 76
} | [
{
"pp": "α : Type u\nβ : Type v\nι : Sort x\ninst✝¹ : CompleteLattice α\ninst✝ : CompleteLattice β\nl : α → β\nu : β → α\ngc : GaloisConnection l u\nf : ι → α\n⊢ IsLUB (range (l ∘ f)) (l (iSup f))",
"usedConstants": [
"Set.range_comp",
"Eq.mpr",
"GaloisConnection.isLUB_l_image",
"con... | rw [range_comp, ← sSup_range]; exact gc.isLUB_l_image (isLUB_sSup _) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.GaloisConnection.Basic | {
"line": 355,
"column": 6
} | {
"line": 357,
"column": 82
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nι : Sort x\nκ : ι → Sort u_1\na₁ a₂ : α\nb₁ b₂ : β\nl : α → β\nu : β → α\ninst✝¹ : PartialOrder β\ninst✝ : SemilatticeInf α\ngi : GaloisInsertion l u\n⊢ ∀ (a b c : β), a ≤ b → a ≤ c → a ≤ l (u b ⊓ u c)",
"usedConstants": [
"GaloisConnection.monotone_u",
... | exact fun a b c hac hbc =>
(gi.le_l_u a).trans <|
gi.gc.monotone_l <| le_inf (gi.gc.monotone_u hac) (gi.gc.monotone_u hbc) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.CompleteBooleanAlgebra | {
"line": 148,
"column": 51
} | {
"line": 149,
"column": 50
} | [
{
"pp": "α : Type u\nminAx : MinimalAxioms α\ns : Set α\nb : α\n⊢ sSup s ⊓ b = ⨆ a ∈ s, a ⊓ b",
"usedConstants": [
"Eq.mpr",
"CompleteLattice.toLattice",
"Iff.of_eq",
"congrArg",
"iSup",
"Order.Frame.MinimalAxioms.toCompleteLattice",
"Membership.mem",
"id",
... | by
simpa only [inf_comm] using @inf_sSup_eq α _ s b | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.CompleteLattice.Basic | {
"line": 769,
"column": 2
} | {
"line": 769,
"column": 37
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝ : CompleteLattice α\nf : β × γ → α\ns : Set β\nt : Set γ\n⊢ ⨆ i, ⨆ j, ⨆ (_ : i ∈ s), ⨆ (_ : j ∈ t), f (i, j) = ⨆ a ∈ s, ⨆ b ∈ t, f (a, b)",
"usedConstants": [
"iSup",
"Membership.mem",
"iSup_comm",
"Prod.mk",
"CompleteSem... | exact iSup_congr fun _ => iSup_comm | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.CompleteBooleanAlgebra | {
"line": 393,
"column": 53
} | {
"line": 394,
"column": 50
} | [
{
"pp": "α : Type u\ninst✝ : Frame α\ns : Set α\nb : α\n⊢ sSup s ⊓ b = ⨆ a ∈ s, a ⊓ b",
"usedConstants": [
"Eq.mpr",
"CompleteLattice.toLattice",
"Iff.of_eq",
"congrArg",
"iSup",
"Membership.mem",
"inf_sSup_eq",
"id",
"SemilatticeInf.toMin",
"inf_c... | by
simpa only [inf_comm] using @inf_sSup_eq α _ s b | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.ConditionallyCompleteLattice.Basic | {
"line": 101,
"column": 2
} | {
"line": 104,
"column": 21
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Preorder α\ninst✝ : SupSet α\ns : Set α\nhs : BddAbove s\n⊢ ↑(sSup s) = sSup ((fun a ↦ ↑a) '' s)",
"usedConstants": [
"Eq.mpr",
"False",
"Option.ctorIdx",
"congrArg",
"HEq.refl",
"False.elim",
"Classical.propDecidable",
"noConfu... | change _ = ite _ _ _
rw [if_neg, preimage_image_eq, if_pos hs]
· exact Option.some_injective _
· rintro ⟨x, _, ⟨⟩⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.ConditionallyCompleteLattice.Basic | {
"line": 101,
"column": 2
} | {
"line": 104,
"column": 21
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Preorder α\ninst✝ : SupSet α\ns : Set α\nhs : BddAbove s\n⊢ ↑(sSup s) = sSup ((fun a ↦ ↑a) '' s)",
"usedConstants": [
"Eq.mpr",
"False",
"Option.ctorIdx",
"congrArg",
"HEq.refl",
"False.elim",
"Classical.propDecidable",
"noConfu... | change _ = ite _ _ _
rw [if_neg, preimage_image_eq, if_pos hs]
· exact Option.some_injective _
· rintro ⟨x, _, ⟨⟩⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Interval.Set.OrderEmbedding | {
"line": 46,
"column": 2
} | {
"line": 46,
"column": 20
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder α\ninst✝ : Lattice β\ne : α ↪o β\nx y : α\n⊢ ⇑e ⁻¹' uIcc (e x) (e y) = uIcc x y",
"usedConstants": [
"le_total"
]
}
] | cases le_total x y | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Order.Interval.Set.OrderEmbedding | {
"line": 50,
"column": 2
} | {
"line": 50,
"column": 20
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder α\ninst✝ : LinearOrder β\ne : α ↪o β\nx y : α\n⊢ ⇑e ⁻¹' uIoc (e x) (e y) = uIoc x y",
"usedConstants": [
"le_total"
]
}
] | cases le_total x y | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Order.Interval.Set.UnorderedInterval | {
"line": 344,
"column": 37
} | {
"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",
... | simp [uIoo] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Order.Interval.Set.UnorderedInterval | {
"line": 344,
"column": 37
} | {
"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",
... | simp [uIoo] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Interval.Set.UnorderedInterval | {
"line": 344,
"column": 37
} | {
"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",
... | simp [uIoo] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Interval.Set.OrdConnected | {
"line": 321,
"column": 2
} | {
"line": 321,
"column": 85
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\ns : Set α\ninst✝ : s.OrdConnected\na b : ↑s\n⊢ Subtype.val '' [[a, b]] = [[↑a, ↑b]]",
"usedConstants": [
"Lattice.toSemilatticeSup",
"congrArg",
"PartialOrder.toPreorder",
"Subtype.instLinearOrder",
"Monotone.map_sup",
"Membe... | simp [uIcc, (Subtype.mono_coe (· ∈ s)).map_inf, (Subtype.mono_coe (· ∈ s)).map_sup] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Order.Interval.Set.OrdConnected | {
"line": 321,
"column": 2
} | {
"line": 321,
"column": 85
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\ns : Set α\ninst✝ : s.OrdConnected\na b : ↑s\n⊢ Subtype.val '' [[a, b]] = [[↑a, ↑b]]",
"usedConstants": [
"Lattice.toSemilatticeSup",
"congrArg",
"PartialOrder.toPreorder",
"Subtype.instLinearOrder",
"Monotone.map_sup",
"Membe... | simp [uIcc, (Subtype.mono_coe (· ∈ s)).map_inf, (Subtype.mono_coe (· ∈ s)).map_sup] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Interval.Set.OrdConnected | {
"line": 321,
"column": 2
} | {
"line": 321,
"column": 85
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\ns : Set α\ninst✝ : s.OrdConnected\na b : ↑s\n⊢ Subtype.val '' [[a, b]] = [[↑a, ↑b]]",
"usedConstants": [
"Lattice.toSemilatticeSup",
"congrArg",
"PartialOrder.toPreorder",
"Subtype.instLinearOrder",
"Monotone.map_sup",
"Membe... | simp [uIcc, (Subtype.mono_coe (· ∈ s)).map_inf, (Subtype.mono_coe (· ∈ s)).map_sup] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.CompleteLatticeIntervals | {
"line": 183,
"column": 6
} | {
"line": 183,
"column": 66
} | [
{
"pp": "case pos\nι : Sort u_1\nα : Type u_2\ns : Set α\ninst✝¹ : ConditionallyCompleteLattice α\na b : α\ninst✝ : Fact (a ≤ b)\nS : Set ↑(Icc a b)\nhS : S = ∅\n⊢ IsLUB S ⟨a, ⋯⟩",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"le_rfl",
"_private.Mathlib.Order.CompleteLatt... | subst hS; simp only [isLUB_empty_iff, isBot_iff_eq_bot]; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.CompleteLatticeIntervals | {
"line": 183,
"column": 6
} | {
"line": 183,
"column": 66
} | [
{
"pp": "case pos\nι : Sort u_1\nα : Type u_2\ns : Set α\ninst✝¹ : ConditionallyCompleteLattice α\na b : α\ninst✝ : Fact (a ≤ b)\nS : Set ↑(Icc a b)\nhS : S = ∅\n⊢ IsLUB S ⟨a, ⋯⟩",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"le_rfl",
"_private.Mathlib.Order.CompleteLatt... | subst hS; simp only [isLUB_empty_iff, isBot_iff_eq_bot]; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 77,
"column": 17
} | {
"line": 77,
"column": 62
} | [
{
"pp": "case step\nm n m✝ : ℕ\na✝ : m.le m✝\nih : m ! ∣ m✝!\n⊢ m ! ∣ m✝.succ !",
"usedConstants": [
"Nat.dvd_trans",
"Nat.factorial",
"Nat.dvd_mul_left",
"Nat.succ"
]
}
] | exact Nat.dvd_trans ih (Nat.dvd_mul_left _ _) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 77,
"column": 17
} | {
"line": 77,
"column": 62
} | [
{
"pp": "case step\nm n m✝ : ℕ\na✝ : m.le m✝\nih : m ! ∣ m✝!\n⊢ m ! ∣ m✝.succ !",
"usedConstants": [
"Nat.dvd_trans",
"Nat.factorial",
"Nat.dvd_mul_left",
"Nat.succ"
]
}
] | exact Nat.dvd_trans ih (Nat.dvd_mul_left _ _) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factorial.Basic | {
"line": 77,
"column": 17
} | {
"line": 77,
"column": 62
} | [
{
"pp": "case step\nm n m✝ : ℕ\na✝ : m.le m✝\nih : m ! ∣ m✝!\n⊢ m ! ∣ m✝.succ !",
"usedConstants": [
"Nat.dvd_trans",
"Nat.factorial",
"Nat.dvd_mul_left",
"Nat.succ"
]
}
] | exact Nat.dvd_trans ih (Nat.dvd_mul_left _ _) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Notation.Support | {
"line": 88,
"column": 6
} | {
"line": 88,
"column": 38
} | [
{
"pp": "case neg\nι : Type u_1\nκ : Type u_2\nN : Type u_4\ninst✝ : One N\nf : ι → κ\ng : ι → N\nx : κ\nhfg : ¬x ∈ f '' mulSupport g\nhf : ¬∃ a, f a = x\n⊢ extend f g 1 x = 1",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Function.extend",
"Pi.instOne",
"Function.exte... | rw [extend_apply' _ _ _ hf]; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Notation.Support | {
"line": 88,
"column": 6
} | {
"line": 88,
"column": 38
} | [
{
"pp": "case neg\nι : Type u_1\nκ : Type u_2\nN : Type u_4\ninst✝ : One N\nf : ι → κ\ng : ι → N\nx : κ\nhfg : ¬x ∈ f '' mulSupport g\nhf : ¬∃ a, f a = x\n⊢ extend f g 1 x = 1",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Function.extend",
"Pi.instOne",
"Function.exte... | rw [extend_apply' _ _ _ hf]; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.Cast.Field | {
"line": 40,
"column": 33
} | {
"line": 43,
"column": 92
} | [
{
"pp": "α : Type u_1\ninst✝ : DivisionRing α\nm n : ℤ\nn_dvd : n ∣ m\nhn : ↑n ≠ 0\n⊢ ↑(m / n) = ↑m / ↑n",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Int.cast",
"Eq.mpr",
"Int.instDiv",
"False",
"... | by
rcases n_dvd with ⟨k, rfl⟩
have : n ≠ 0 := by rintro rfl; simp at hn
rw [Int.mul_ediv_cancel_left _ this, mul_comm n, Int.cast_mul, mul_div_cancel_right₀ _ hn] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Round | {
"line": 140,
"column": 81
} | {
"line": 141,
"column": 44
} | [
{
"pp": "α : Type u_2\ninst✝³ : Ring α\ninst✝² : LinearOrder α\ninst✝¹ : IsStrictOrderedRing α\ninst✝ : FloorRing α\nx : α\ny : ℕ\n⊢ round (↑y + x) = ↑y + round x",
"usedConstants": [
"Eq.mpr",
"round_add_natCast",
"Ring.toNonAssocRing",
"congrArg",
"AddGroupWithOne.toAddMonoid... | by
rw [add_comm, round_add_natCast, add_comm] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Group.Basic | {
"line": 29,
"column": 75
} | {
"line": 32,
"column": 42
} | [
{
"pp": "α : Type u_1\ninst✝² : CommGroup α\ninst✝¹ : PartialOrder α\ninst✝ : IsOrderedMonoid α\na : α\nha : 1 < a\n⊢ StrictMono fun n ↦ a ^ n",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"HMul.hMul",
"Monoid.toMulOneClass",
"IsLeftCancelMul.mulLeftStrictMono_of_mulLeftMono"... | by
refine strictMono_int_of_lt_succ fun n ↦ ?_
rw [zpow_add_one]
exact lt_mul_of_one_lt_right' (a ^ n) ha | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Group.Basic | {
"line": 68,
"column": 2
} | {
"line": 68,
"column": 32
} | [
{
"pp": "α : Type u_1\ninst✝² : CommGroup α\ninst✝¹ : PartialOrder α\ninst✝ : IsOrderedMonoid α\nn : ℤ\nhn : 0 < n\na b : α\nhab : a < b\n⊢ (fun x ↦ x ^ n) a < (fun x ↦ x ^ n) b",
"usedConstants": [
"instIsRightCancelMulOfMulRightReflectLE",
"IsLeftCancelMul.mulLeftReflectLE_of_mulLeftReflectLT"... | rw [← one_lt_div', ← div_zpow] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 220,
"column": 26
} | {
"line": 220,
"column": 43
} | [
{
"pp": "R : Type u_2\ninst✝³ : Ring R\ninst✝² : LinearOrder R\ninst✝¹ : FloorRing R\ninst✝ : IsOrderedRing R\nn : ℕ\na : R\n⊢ ⌊↑↑n + a⌋ = ↑n + ⌊a⌋",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.floor",
"congrArg",
"Int.floor_intCast_add",
"id",
"Distrib.toAdd",
... | floor_intCast_add | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.AddTorsor.Defs | {
"line": 155,
"column": 88
} | {
"line": 156,
"column": 41
} | [
{
"pp": "G : Type u_1\nP : Type u_2\ninst✝ : AddGroup G\nT : AddTorsor G P\np₁ p₂ p₃ : P\n⊢ p₁ -ᵥ p₃ - (p₂ -ᵥ p₃) = p₁ -ᵥ p₂",
"usedConstants": [
"Eq.mpr",
"AddMonoid.toAddSemigroup",
"congrArg",
"vsub_vadd_eq_vsub_sub",
"HSub.hSub",
"id",
"AddTorsor.toVSub",
... | by
rw [← vsub_vadd_eq_vsub_sub, vsub_vadd] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 730,
"column": 4
} | {
"line": 730,
"column": 49
} | [
{
"pp": "case refine_1\nR : Type u_2\ninst✝³ : Ring R\ninst✝² : LinearOrder R\ninst✝¹ : FloorRing R\ninst✝ : IsOrderedRing R\na : R\nh : ⌈a⌉ = ⌊a⌋ + 1\nht : a ∈ range Int.cast\nh0 : ↑⌊a⌋ = ↑⌈a⌉\n⊢ False",
"usedConstants": [
"Int.cast",
"Int.floor",
"congrArg",
"Eq.mp",
"Int",
... | rw [h, cast_add, cast_one, left_eq_add] at h0 | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Archimedean.Basic | {
"line": 258,
"column": 29
} | {
"line": 258,
"column": 61
} | [
{
"pp": "K : Type u_4\ninst✝⁴ : Semifield K\ninst✝³ : LinearOrder K\ninst✝² : IsStrictOrderedRing K\ninst✝¹ : Archimedean K\nx y : K\ninst✝ : ExistsAddOfLE K\nhx : 0 < x\nhy : y < 1\ny_pos : 0 < y\nq : ℕ\nhq : x⁻¹ < (y ^ q)⁻¹\n⊢ y ^ q < x",
"usedConstants": [
"pow_pos",
"Preorder.toLT",
"G... | inv_lt_inv₀ hx (pow_pos y_pos _) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Ring | {
"line": 745,
"column": 49
} | {
"line": 745,
"column": 68
} | [
{
"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⊢ ↑⌊a⌋ < a",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Preorder.toLT",
"Int.floor",
"AddGroupWithOne.toAddGroup",
"congrArg"... | ← self_sub_fract a, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.AddConstMap.Basic | {
"line": 282,
"column": 8
} | {
"line": 282,
"column": 43
} | [
{
"pp": "F : Type u_1\nG : Type u_2\nH : Type u_3\ninst✝⁷ : FunLike F G H\na : G\nb : H\ninst✝⁶ : AddCommGroup G\ninst✝⁵ : LinearOrder G\ninst✝⁴ : IsOrderedAddMonoid G\ninst✝³ : Archimedean G\ninst✝² : AddGroup H\ninst✝¹ : AddConstMapClass F G H a b\nf : F\nR : H → H → Prop\ninst✝ : IsTrans H R\nha : 0 < a\nl :... | refine hR (k • b) (hf _ ?_ _ ?_ ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Multiset.Count | {
"line": 213,
"column": 4
} | {
"line": 213,
"column": 33
} | [
{
"pp": "case cons\nα : Type u_1\nr : α → α → Prop\ninst✝² : IsTrans α r\ninst✝¹ : Std.Symm r\nx : α\ninst✝ : DecidablePred (r x)\ny : α\ns : Multiset α\nih : ∀ {t : Multiset α}, Rel r s t → countP (r x) s = countP (r x) t\nb : α\nbs : Multiset α\nhb1 : r y b\nhb2 : Rel r s bs\nh : Rel r (y ::ₘ s) (b ::ₘ bs)\n⊢... | simp only [Nat.add_right_inj] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Multiset.AddSub | {
"line": 344,
"column": 67
} | {
"line": 345,
"column": 44
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t u : Multiset α\nhstu : s + t = u\n⊢ s = u - t",
"usedConstants": [
"Eq.mpr",
"congrArg",
"HSub.hSub",
"Multiset",
"id",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"Eq.refl",
"Multiset.add_sub_cancel_right... | by
rw [← hstu, Multiset.add_sub_cancel_right] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Nodup | {
"line": 121,
"column": 2
} | {
"line": 122,
"column": 32
} | [
{
"pp": "α : Type u\nxs : List α\nn m : Fin xs.length\nh : xs.get n = xs.get m\nhne : n ≠ m\n⊢ ¬xs.Nodup",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.get",
"id",
"List.Nodup",
"propext",
"List.nodup_iff_injective_get",
"Function.Injective",
"Fin",
... | rw [nodup_iff_injective_get]
exact fun hinj => hne (hinj h) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Nodup | {
"line": 121,
"column": 2
} | {
"line": 122,
"column": 32
} | [
{
"pp": "α : Type u\nxs : List α\nn m : Fin xs.length\nh : xs.get n = xs.get m\nhne : n ≠ m\n⊢ ¬xs.Nodup",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.get",
"id",
"List.Nodup",
"propext",
"List.nodup_iff_injective_get",
"Function.Injective",
"Fin",
... | rw [nodup_iff_injective_get]
exact fun hinj => hne (hinj h) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Nodup | {
"line": 195,
"column": 4
} | {
"line": 195,
"column": 24
} | [
{
"pp": "case cons\nα : Type u\nβ : Type v\nf : α → β\nhd : α\ntl : List α\nih : (map f tl).Nodup → ∀ ⦃x : α⦄, x ∈ tl → ∀ ⦃y : α⦄, y ∈ tl → f x = f y → x = y\nd : (∀ (x : α), x ∈ tl → f x ≠ f hd) ∧ (map f tl).Nodup\n⊢ ∀ ⦃x : α⦄, x ∈ hd :: tl → ∀ ⦃y : α⦄, y ∈ hd :: tl → f x = f y → x = y",
"usedConstants": [... | simp only [mem_cons] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Multiset.AddSub | {
"line": 393,
"column": 2
} | {
"line": 393,
"column": 31
} | [
{
"pp": "α : Type u_1\nβ : Type v\nr : α → β → Prop\nas : Multiset α\nbs₀ bs₁ : Multiset β\n⊢ Rel r as (bs₀ + bs₁) ↔ ∃ as₀ as₁, Rel r as₀ bs₀ ∧ Rel r as₁ bs₁ ∧ as = as₀ + as₁",
"usedConstants": [
"Eq.mpr",
"Multiset.rel_flip",
"congrArg",
"Exists",
"Multiset",
"flip",
... | rw [← rel_flip, rel_add_left] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Multiset.MapFold | {
"line": 301,
"column": 2
} | {
"line": 301,
"column": 43
} | [
{
"pp": "α : Type u_1\nβ : Type v\nf : α → β → β\ninst✝ : LeftCommutative f\nx : β\nq : α → Prop\np : β → Prop\ns : Multiset α\nhpqf : ∀ (a : α) (b : β), q a → p b → p (f a b)\npx : p x\nq_s : ∀ (a : α), a ∈ s → q a\n⊢ p (foldr f x s)",
"usedConstants": [
"Eq.mpr",
"Multiset.foldr",
"congr... | induction s using Multiset.induction with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Multiset.Dedup | {
"line": 131,
"column": 42
} | {
"line": 132,
"column": 79
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : List α\nh : t ⊆ s\n⊢ (s ++ t).dedup ~ s.dedup",
"usedConstants": [
"Eq.mpr",
"Multiset.coe_add",
"congrArg",
"Multiset.dedup",
"List.dedup",
"Multiset",
"id",
"List.Perm",
"Multiset.coe_eq_coe",
"... | by
rw [← coe_eq_coe, ← coe_dedup, ← coe_add, Subset.dedup_add_left h, coe_dedup] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Multiset.Filter | {
"line": 262,
"column": 2
} | {
"line": 262,
"column": 43
} | [
{
"pp": "α : Type u_1\nβ : Type v\nf : α → β\np : α → Prop\ninst✝ : DecidablePred p\ns : Multiset α\n⊢ map f (filter p s) = filterMap (fun a ↦ if p a then some (f a) else none) s",
"usedConstants": [
"Eq.mpr",
"Multiset.filterMap",
"Multiset.filter_cons",
"Multiset.map",
"congr... | induction s using Multiset.induction with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Finset.Insert | {
"line": 468,
"column": 4
} | {
"line": 468,
"column": 45
} | [
{
"pp": "α : Type u_3\nmotive : Finset α → Prop\nempty : motive ∅\ncons : ∀ (a : α) (s : Finset α) (h : a ∉ s), motive s → motive (Finset.cons a s h)\ns : Multiset α\nnd : s.Nodup\n⊢ motive { val := s, nodup := nd }",
"usedConstants": [
"Eq.mpr",
"Multiset.Nodup",
"Finset.cons",
"con... | induction s using Multiset.induction with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Fin.Basic | {
"line": 201,
"column": 2
} | {
"line": 201,
"column": 26
} | [
{
"pp": "k l : ℕ\ninst✝¹ : NeZero k\ninst✝ : NeZero l\nh : k = l\nx : Fin k\n⊢ Fin.cast h x = 0 ↔ x = 0",
"usedConstants": [
"congrArg",
"Fin.instOfNat",
"instOfNatNat",
"Fin.val",
"iff_self",
"Fin.cast",
"Iff",
"_private.Mathlib.Data.Fin.Basic.0.Fin.cast_eq_z... | simp [← val_eq_zero_iff] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Fin.Basic | {
"line": 201,
"column": 2
} | {
"line": 201,
"column": 26
} | [
{
"pp": "k l : ℕ\ninst✝¹ : NeZero k\ninst✝ : NeZero l\nh : k = l\nx : Fin k\n⊢ Fin.cast h x = 0 ↔ x = 0",
"usedConstants": [
"congrArg",
"Fin.instOfNat",
"instOfNatNat",
"Fin.val",
"iff_self",
"Fin.cast",
"Iff",
"_private.Mathlib.Data.Fin.Basic.0.Fin.cast_eq_z... | simp [← val_eq_zero_iff] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.Basic | {
"line": 201,
"column": 2
} | {
"line": 201,
"column": 26
} | [
{
"pp": "k l : ℕ\ninst✝¹ : NeZero k\ninst✝ : NeZero l\nh : k = l\nx : Fin k\n⊢ Fin.cast h x = 0 ↔ x = 0",
"usedConstants": [
"congrArg",
"Fin.instOfNat",
"instOfNatNat",
"Fin.val",
"iff_self",
"Fin.cast",
"Iff",
"_private.Mathlib.Data.Fin.Basic.0.Fin.cast_eq_z... | simp [← val_eq_zero_iff] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fin.Basic | {
"line": 433,
"column": 57
} | {
"line": 436,
"column": 64
} | [
{
"pp": "n m : ℕ\ni : Fin (m * n)\nH₁ : ↑i % n + 1 ≤ n\nH₂ : ↑i / n < m\n⊢ (m * n - (↑i / n * n + ↑i % n + 1)) % n = ((m - ↑i / n - 1) * n + (n - (↑i % n + 1))) % n",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"congrArg",
"HSub.hSub",
"Nat.le_sub_of_add_le'",
... | by
rw [Nat.mul_sub_right_distrib, Nat.one_mul, Nat.sub_add_sub_cancel _ H₁,
Nat.mul_sub_right_distrib, Nat.sub_sub, Nat.add_assoc]
exact Nat.le_mul_of_pos_left _ <| Nat.le_sub_of_add_le' H₂ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Fin.Basic | {
"line": 469,
"column": 8
} | {
"line": 469,
"column": 33
} | [
{
"pp": "case mpr.refine_2.inl\nn : ℕ\nα : Type u_1\nr : α → α → Prop\ninst✝ : IsTrans α r\nf : Fin (n + 1) → α\nH : ∀ (i : Fin n), r (f i.castSucc) (f i.succ)\ni : Fin (n + 1)\nj : Fin n\nihj : (fun x1 x2 ↦ x1 < x2) i j.castSucc → r (f i) (f j.castSucc)\nhij✝ : i ≤ j.castSucc\nhij : ↑i = ↑j.castSucc\n⊢ r (f i)... | obtain rfl := Fin.ext hij | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Order.Fin.Basic | {
"line": 281,
"column": 6
} | {
"line": 281,
"column": 26
} | [
{
"pp": "n : ℕ\ni j : Fin (n + 1)\nh : i < j\nhij : i.predAbove i.succ = j.predAbove i.succ\n⊢ i = j",
"usedConstants": [
"Fin.succ",
"congrArg",
"Eq.mp",
"instOfNatNat",
"Fin.predAbove",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"OfNat.ofNat",... | predAbove_succ_self, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fin.SuccPred | {
"line": 796,
"column": 2
} | {
"line": 796,
"column": 33
} | [
{
"pp": "n : ℕ\ni : Fin (n + 2)\nhi : i ≠ last (n + 1)\n⊢ (last n).predAbove i = i.castPred hi",
"usedConstants": [
"congrArg",
"Exists",
"Eq.mp",
"Ne",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Fin.last",
"propext",
"instAddNat",
... | rw [← exists_castSucc_eq] at hi | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 321,
"column": 4
} | {
"line": 321,
"column": 35
} | [
{
"pp": "case refine_1\nm n : ℕ\nα : Sort u_1\nu : Fin m → α\nv : Fin n → α\nhv : n = 0\nl : Fin m\n⊢ u l = u (Fin.cast ⋯ (castAdd n l))",
"usedConstants": [
"Fin.castAdd",
"Fin.ext",
"congr_arg",
"instHAdd",
"Fin.cast",
"HAdd.hAdd",
"Nat",
"instAddNat",
... | refine congr_arg u (Fin.ext ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Fintype.Card | {
"line": 424,
"column": 2
} | {
"line": 426,
"column": 10
} | [
{
"pp": "α : Type u_4\ninst✝ : Fintype α\nx : α\nh : Fintype.card α = 1\n⊢ univ = {x}",
"usedConstants": [
"Finset.univ",
"instReflLe",
"congrArg",
"Finset",
"Std.le_refl._simp_1",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat.instPreorder",
"Nat",
... | symm
apply eq_of_subset_of_card_le (subset_univ {x})
simp [h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fintype.Card | {
"line": 424,
"column": 2
} | {
"line": 426,
"column": 10
} | [
{
"pp": "α : Type u_4\ninst✝ : Fintype α\nx : α\nh : Fintype.card α = 1\n⊢ univ = {x}",
"usedConstants": [
"Finset.univ",
"instReflLe",
"congrArg",
"Finset",
"Std.le_refl._simp_1",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat.instPreorder",
"Nat",
... | symm
apply eq_of_subset_of_card_le (subset_univ {x})
simp [h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 397,
"column": 69
} | {
"line": 399,
"column": 6
} | [
{
"pp": "m n : ℕ\nα : Sort u_1\nf : Fin (m + n) → α\n⊢ (append (fun i ↦ f (castAdd n i)) fun i ↦ f (natAdd m i)) = f",
"usedConstants": [
"dite_congr",
"Fin.natAdd",
"Fin.castAdd",
"congrArg",
"ite_self",
"Eq.rec",
"Fin.castAdd_castLT",
"id",
"Fin.addCas... | by
unfold append addCases
simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 567,
"column": 2
} | {
"line": 568,
"column": 34
} | [
{
"pp": "n : ℕ\nα : Fin (n + 1) → Sort u_1\nx : α (last n)\np : (i : Fin n) → α i.castSucc\nz : α (last n)\n⊢ update (snoc p x) (last n) z = snoc p z",
"usedConstants": [
"False",
"Fin.castSucc_ne_last._simp_1",
"Function.update",
"Fin.snoc_castSucc",
"congrArg",
"instDec... | ext j
cases j using lastCases <;> simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 567,
"column": 2
} | {
"line": 568,
"column": 34
} | [
{
"pp": "n : ℕ\nα : Fin (n + 1) → Sort u_1\nx : α (last n)\np : (i : Fin n) → α i.castSucc\nz : α (last n)\n⊢ update (snoc p x) (last n) z = snoc p z",
"usedConstants": [
"False",
"Fin.castSucc_ne_last._simp_1",
"Function.update",
"Fin.snoc_castSucc",
"congrArg",
"instDec... | ext j
cases j using lastCases <;> simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1278,
"column": 59
} | {
"line": 1283,
"column": 63
} | [
{
"pp": "n : ℕ\nα : Sort u_1\nβ : Sort u_2\nopα : α → α → α\nopβ : β → β → β\nf : α → β\nhf : ∀ (x y : α), f (opα x y) = opβ (f x) (f y)\nj : Fin (n + 1)\ng : Fin (n + 1) → α\n⊢ f ∘ j.contractNth opα g = j.contractNth opβ (f ∘ g)",
"usedConstants": [
"Preorder.toLT",
"Fin.succ",
"congrArg"... | by
ext x
rcases lt_trichotomy (x : ℕ) j with (h | h | h)
· simp only [Function.comp_apply, contractNth_apply_of_lt, h]
· simp only [Function.comp_apply, contractNth_apply_of_eq, h, hf]
· simp only [Function.comp_apply, contractNth_apply_of_gt, h] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.Fold | {
"line": 54,
"column": 54
} | {
"line": 56,
"column": 74
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nop : β → β → β\nhc : Std.Commutative op\nha : Std.Associative op\nf : α → β\nb : β\ns : Finset α\na : α\ninst✝ : DecidableEq α\nh : a ∉ s\n⊢ fold op b f (insert a s) = op (f a) (fold op b f s)",
"usedConstants": [
"Multiset.fold_cons_left",
"Finset.insert_val... | by
unfold fold
rw [insert_val, ndinsert_of_notMem h, Multiset.map_cons, fold_cons_left] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Rotate | {
"line": 69,
"column": 67
} | {
"line": 69,
"column": 72
} | [
{
"pp": "α : Type u\na : α\nl : List α\nn : ℕ\nh : n + 1 ≤ (a :: l).length\nhnl : n ≤ l.length\nhnl' : n ≤ (l ++ [a]).length\n⊢ drop n (l ++ [a]) ++ take n (l ++ [a]) = drop n l ++ take (n + 1) (a :: l)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.take.eq_3",
"id",
"instOfN... | take, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Rotate | {
"line": 76,
"column": 24
} | {
"line": 78,
"column": 26
} | [
{
"pp": "α : Type u\na : α\nl : List α\nn m : ℕ\n⊢ ((a :: l).rotate' (n + 1)).rotate' m = (a :: l).rotate' (n + 1 + m)",
"usedConstants": [
"List.rotate'_cons_succ",
"Eq.mpr",
"Nat.succ_eq_add_one",
"congrArg",
"id",
"instOfNatNat",
"List.cons",
"instHAppendOf... | by
rw [rotate'_cons_succ, rotate'_rotate' _ n, Nat.add_right_comm, ← rotate'_cons_succ,
Nat.succ_eq_add_one] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 112,
"column": 2
} | {
"line": 112,
"column": 68
} | [
{
"pp": "α : Type u_2\ninst✝ : DecidableEq α\nl : List α\n⊢ (map (fun x ↦ count x l) l.dedup).sum = l.length",
"usedConstants": [
"List.countP",
"instDecidableTrue",
"congrArg",
"List.filter_true",
"List.map",
"AddMonoid.toAddZeroClass",
"List.sum",
"Nat.instA... | simpa using sum_map_count_dedup_filter_eq_countP (fun _ => True) l | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 112,
"column": 2
} | {
"line": 112,
"column": 68
} | [
{
"pp": "α : Type u_2\ninst✝ : DecidableEq α\nl : List α\n⊢ (map (fun x ↦ count x l) l.dedup).sum = l.length",
"usedConstants": [
"List.countP",
"instDecidableTrue",
"congrArg",
"List.filter_true",
"List.map",
"AddMonoid.toAddZeroClass",
"List.sum",
"Nat.instA... | simpa using sum_map_count_dedup_filter_eq_countP (fun _ => True) l | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 112,
"column": 2
} | {
"line": 112,
"column": 68
} | [
{
"pp": "α : Type u_2\ninst✝ : DecidableEq α\nl : List α\n⊢ (map (fun x ↦ count x l) l.dedup).sum = l.length",
"usedConstants": [
"List.countP",
"instDecidableTrue",
"congrArg",
"List.filter_true",
"List.map",
"AddMonoid.toAddZeroClass",
"List.sum",
"Nat.instA... | simpa using sum_map_count_dedup_filter_eq_countP (fun _ => True) l | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 130,
"column": 55
} | {
"line": 130,
"column": 72
} | [
{
"pp": "l s : List ℕ\nhs : s ∈ l.ranges\n⊢ Pairwise (fun x1 x2 ↦ x1 ≠ x2) (range l.sum)",
"usedConstants": [
"AddMonoid.toAddZeroClass",
"List.sum",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"AddZero.toZero",
"List.nodup_range",
"Nat",
"instAddNat"
]... | exact nodup_range | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.List.Rotate | {
"line": 319,
"column": 2
} | {
"line": 319,
"column": 31
} | [
{
"pp": "α : Type u\nl : List α\nn : ℕ\n⊢ l.reverse =\n l.reverse.rotate\n (l.reverse.length - (l.reverse.length - n % l.reverse.length) % l.reverse.length +\n (l.reverse.length - n % l.reverse.length))",
"usedConstants": [
"Nat.instMod",
"instHMod",
"HMod.hMod",
"Nat"... | let k := n % l.reverse.length | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Data.Multiset.Bind | {
"line": 395,
"column": 8
} | {
"line": 395,
"column": 19
} | [
{
"pp": "α : Type u_1\nσ : α → Type u_4\ns✝ : Multiset α\na : α\ns : Multiset α\nIH : ∀ (t u : (a : α) → Multiset (σ a)), (s.sigma fun a ↦ t a + u a) = s.sigma t + s.sigma u\nt u : (a : α) → Multiset (σ a)\n⊢ ((a ::ₘ s).sigma fun a ↦ t a + u a) = (a ::ₘ s).sigma t + (a ::ₘ s).sigma u",
"usedConstants": [
... | cons_sigma, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Finset.Prod | {
"line": 282,
"column": 63
} | {
"line": 283,
"column": 23
} | [
{
"pp": "α : Type u_1\ns : Finset α\ninst✝ : DecidableEq α\n⊢ s.diag = {a ∈ s ×ˢ s | a.1 = a.2}",
"usedConstants": [
"Finset.mem_filter._simp_1",
"SProd.sprod",
"congrArg",
"and_self",
"Finset",
"Finset.ext",
"Membership.mem",
"Finset.mem_product._simp_1",
... | by
ext; simp +contextual | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Set.Lattice.Image | {
"line": 360,
"column": 51
} | {
"line": 360,
"column": 90
} | [
{
"pp": "α : Type u_1\nι : Sort u_9\nκ : Sort u_10\nf : ι → Set α\ng : κ → Set α\n⊢ (⋃ i, f i) ∩ ⋃ j, g j = ⋃ i, ⋃ j, f i ∩ g j",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Set.instInter",
"Set.iUnion_inter",
"Inter.inter",
"funext",
"True",
"eq_sel... | by simp_rw [iUnion_inter, inter_iUnion] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Subgroup.Map | {
"line": 329,
"column": 42
} | {
"line": 330,
"column": 43
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH K : Subgroup G\nh : H ≤ K\n⊢ map K.subtype (H.subgroupOf K) = H",
"usedConstants": [
"Eq.mpr",
"Subgroup.subgroupOf",
"CompleteLattice.toLattice",
"Subgroup.map",
"congrArg",
"Subgroup.subtype",
"PartialOrder.toPreorder",
... | by
rwa [subgroupOf_map_subtype, inf_eq_left] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Subgroup.Basic | {
"line": 437,
"column": 55
} | {
"line": 441,
"column": 26
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Group G\nH : Subgroup G\nN : Type u_5\ninst✝ : Group N\nf : N →* G\nh : H ≤ f.range\n⊢ comap f (normalizer ↑H) = normalizer ↑(comap f H)",
"usedConstants": [
"Eq.mpr",
"le_refl",
"Subgroup.map",
"Subgroup.le_normalizer_comap",
"congrArg",
"... | by
apply le_antisymm (le_normalizer_comap f)
rw [← map_le_iff_le_comap]
apply (le_normalizer_map f).trans
rw [map_comap_eq_self h] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Pairing | {
"line": 102,
"column": 49
} | {
"line": 102,
"column": 89
} | [
{
"pp": "a b : ℕ\n⊢ a ≤ pair a b",
"usedConstants": [
"congrArg",
"Nat.unpair",
"Eq.mp",
"Prod.mk",
"LE.le",
"instLENat",
"Prod.fst",
"Nat.pair",
"Nat",
"congrFun'",
"Nat.unpair_pair",
"Prod",
"Nat.unpair_left_le"
]
}
] | by simpa using unpair_left_le (pair a b) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Logic.Encodable.Basic | {
"line": 225,
"column": 19
} | {
"line": 225,
"column": 75
} | [
{
"pp": "α✝ : Type u_1\nβ : Type u_2\nα : Type u_3\ninst✝ : Encodable α\nx✝ : α\n⊢ (fun n ↦ (decode₂ α ↑n).get ⋯) ((fun a ↦ ⟨encode a, ⋯⟩) x✝) = x✝",
"usedConstants": [
"Set.mem_range_self",
"Eq.mpr",
"congrArg",
"Encodable.equivRangeEncode._proof_1",
"Encodable.decode₂",
... | dsimp; rw [← Option.some_inj, Option.some_get, encodek₂] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Logic.Encodable.Basic | {
"line": 225,
"column": 19
} | {
"line": 225,
"column": 75
} | [
{
"pp": "α✝ : Type u_1\nβ : Type u_2\nα : Type u_3\ninst✝ : Encodable α\nx✝ : α\n⊢ (fun n ↦ (decode₂ α ↑n).get ⋯) ((fun a ↦ ⟨encode a, ⋯⟩) x✝) = x✝",
"usedConstants": [
"Set.mem_range_self",
"Eq.mpr",
"congrArg",
"Encodable.equivRangeEncode._proof_1",
"Encodable.decode₂",
... | dsimp; rw [← Option.some_inj, Option.some_get, encodek₂] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Submonoid.Membership | {
"line": 74,
"column": 2
} | {
"line": 74,
"column": 41
} | [
{
"pp": "case hS\nM : Type u_1\ninst✝ : MulOneClass M\nι : Type u_4\np : ι → Prop\nhp : Nonempty (Subtype p)\nS : ι → Submonoid M\nhS : DirectedOn ((fun x1 x2 ↦ x1 ≤ x2) on S) {i | p i}\nx : M\n⊢ Directed (fun x1 x2 ↦ x1 ≤ x2) fun x ↦ S ↑x",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Direct... | rw [← Function.comp_def, directed_comp] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Choose.Basic | {
"line": 118,
"column": 23
} | {
"line": 118,
"column": 48
} | [
{
"pp": "x✝ : ℕ\nhk : x✝ ≤ 0\n⊢ 0 < choose 0 x✝",
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"congrArg",
"id",
"instOfNatNat",
"Nat",
"LT.lt",
"instLTNat",
"OfNat.ofNat",
"Eq",
"Nat.eq_zero_of_le_zero"
]
}
] | Nat.eq_zero_of_le_zero hk | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Choose.Basic | {
"line": 319,
"column": 2
} | {
"line": 319,
"column": 89
} | [
{
"pp": "r n : ℕ\nh : r < n / 2\n⊢ n.choose r ≤ n.choose (r + 1)",
"usedConstants": [
"Nat.choose",
"instHDiv",
"Nat.sub_pos_of_lt",
"HSub.hSub",
"HDiv.hDiv",
"Nat.div_le_self",
"instSubNat",
"instOfNatNat",
"instHAdd",
"instHSub",
"HAdd.hAdd... | refine Nat.le_of_mul_le_mul_right ?_ (Nat.sub_pos_of_lt (h.trans_le (n.div_le_self 2))) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.List.Sublists | {
"line": 72,
"column": 2
} | {
"line": 72,
"column": 67
} | [
{
"pp": "α : Type u\na : α\nl : List α\n⊢ (a :: l).sublists' = l.sublists' ++ map (cons a) l.sublists'",
"usedConstants": [
"List.sublists'",
"List.sublists'Aux_eq_map",
"congrArg",
"List.sublists'_eq_sublists'Aux",
"List.map",
"List.sublists'Aux",
"List.cons",
... | simp [sublists'_eq_sublists'Aux, foldr_cons, sublists'Aux_eq_map] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Sublists | {
"line": 72,
"column": 2
} | {
"line": 72,
"column": 67
} | [
{
"pp": "α : Type u\na : α\nl : List α\n⊢ (a :: l).sublists' = l.sublists' ++ map (cons a) l.sublists'",
"usedConstants": [
"List.sublists'",
"List.sublists'Aux_eq_map",
"congrArg",
"List.sublists'_eq_sublists'Aux",
"List.map",
"List.sublists'Aux",
"List.cons",
... | simp [sublists'_eq_sublists'Aux, foldr_cons, sublists'Aux_eq_map] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sublists | {
"line": 72,
"column": 2
} | {
"line": 72,
"column": 67
} | [
{
"pp": "α : Type u\na : α\nl : List α\n⊢ (a :: l).sublists' = l.sublists' ++ map (cons a) l.sublists'",
"usedConstants": [
"List.sublists'",
"List.sublists'Aux_eq_map",
"congrArg",
"List.sublists'_eq_sublists'Aux",
"List.map",
"List.sublists'Aux",
"List.cons",
... | simp [sublists'_eq_sublists'Aux, foldr_cons, sublists'Aux_eq_map] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Sublists | {
"line": 140,
"column": 2
} | {
"line": 141,
"column": 93
} | [
{
"pp": "α : Type u\na : α\nl : List α\n⊢ ([a] ++ l).sublists = do\n let x ← l.sublists\n [x, a :: x]",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.map",
"List.sublists",
"id",
"List.instMonad",
"List.sublists_append",
"List.cons",
"instHAppendO... | rw [sublists_append]
simp only [sublists_singleton, map_cons, bind_eq_flatMap, nil_append, cons_append, map_nil] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sublists | {
"line": 140,
"column": 2
} | {
"line": 141,
"column": 93
} | [
{
"pp": "α : Type u\na : α\nl : List α\n⊢ ([a] ++ l).sublists = do\n let x ← l.sublists\n [x, a :: x]",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.map",
"List.sublists",
"id",
"List.instMonad",
"List.sublists_append",
"List.cons",
"instHAppendO... | rw [sublists_append]
simp only [sublists_singleton, map_cons, bind_eq_flatMap, nil_append, cons_append, map_nil] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Sublists | {
"line": 396,
"column": 4
} | {
"line": 396,
"column": 67
} | [
{
"pp": "case append_singleton\nα : Type u\nl' : List α\na : α\nih : ∀ (l₁ l₂ : List α), (l₁, l₂) ∈ l'.sublists.zip l'.sublists.reverse → l₁ ++ l₂ ~ l'\nl₁ l₂ : List α\nh :\n (∃ a_1 b, (a_1, b) ∈ l'.sublists.zip l'.sublists.reverse ∧ id a_1 = l₁ ∧ b ++ [a] = l₂) ∨\n ∃ a_1 b, (a_1, b) ∈ l'.sublists.zip l'.su... | rcases h with (⟨l₁, l₂', h, rfl, rfl⟩ | ⟨l₁', l₂, h, rfl, rfl⟩) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.List.Sublists | {
"line": 397,
"column": 10
} | {
"line": 397,
"column": 24
} | [
{
"pp": "case append_singleton.inl\nα : Type u\nl' : List α\na : α\nih : ∀ (l₁ l₂ : List α), (l₁, l₂) ∈ l'.sublists.zip l'.sublists.reverse → l₁ ++ l₂ ~ l'\nl₁ l₂' : List α\nh : (l₁, l₂') ∈ l'.sublists.zip l'.sublists.reverse\n⊢ id l₁ ++ (l₂' ++ [a]) ~ l' ++ [a]",
"usedConstants": [
"Eq.mpr",
"L... | ← append_assoc | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Sublists | {
"line": 401,
"column": 10
} | {
"line": 401,
"column": 24
} | [
{
"pp": "case append_singleton.inr\nα : Type u\nl' : List α\na : α\nih : ∀ (l₁ l₂ : List α), (l₁, l₂) ∈ l'.sublists.zip l'.sublists.reverse → l₁ ++ l₂ ~ l'\nl₁' l₂ : List α\nh : (l₁', l₂) ∈ l'.sublists.zip l'.sublists.reverse\n⊢ l₁' ++ (id l₂ ++ [a]) ~ l' ++ [a]",
"usedConstants": [
"Eq.mpr",
"L... | ← append_assoc | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Sublists | {
"line": 411,
"column": 40
} | {
"line": 411,
"column": 51
} | [
{
"pp": "case cons\nα : Type u\na : α\nl : List α\nIH : ∀ (l₁ l₂ : List α), (l₁, l₂) ∈ l.sublists'.zip l.sublists'.reverse → l₁ ++ l₂ ~ l\nl₁ l₂ : List α\nh : (l₁, l₂) ∈ (l.sublists' ++ map (cons a) l.sublists').zip ((map (cons a) l.sublists').reverse ++ l.sublists'.reverse)\n⊢ l₁ ++ l₂ ~ a :: l",
"usedCons... | zip_append, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Multiset.Powerset | {
"line": 203,
"column": 4
} | {
"line": 205,
"column": 63
} | [
{
"pp": "α : Type u_1\nn : ℕ\nl : List α\ns : Multiset α\n⊢ ∀ (a : List α), (∃ a_1, (a_1 <+ l ∧ a_1.length = n) ∧ a_1 ~ a) ↔ (∃ l_1, l_1 ~ a ∧ l_1 <+ l) ∧ a.length = n",
"usedConstants": [
"_private.Mathlib.Data.Multiset.Powerset.0.Multiset.mem_powersetCardAux.match_1_8",
"Exists",
"List.P... | exact fun l₁ =>
⟨fun ⟨l₂, ⟨s, e⟩, p⟩ => ⟨⟨_, p, s⟩, p.symm.length_eq.trans e⟩,
fun ⟨⟨l₂, p, s⟩, e⟩ => ⟨_, ⟨s, p.length_eq.trans e⟩, p⟩⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 383,
"column": 17
} | {
"line": 383,
"column": 50
} | [
{
"pp": "case singleton\nα : Type u_2\nι : Type u_5\ninst✝ : BooleanAlgebra α\ns : Finset ι\nf : ι → α\na : α\na✝ : ι\n⊢ ({a✝}.inf fun b ↦ a \\ f b) = a \\ {a✝}.sup f",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"congrArg",
"Finset.sup_singleton",
"Finset",
... | rw [sup_singleton, inf_singleton] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 383,
"column": 17
} | {
"line": 383,
"column": 50
} | [
{
"pp": "case singleton\nα : Type u_2\nι : Type u_5\ninst✝ : BooleanAlgebra α\ns : Finset ι\nf : ι → α\na : α\na✝ : ι\n⊢ ({a✝}.inf fun b ↦ a \\ f b) = a \\ {a✝}.sup f",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"congrArg",
"Finset.sup_singleton",
"Finset",
... | rw [sup_singleton, inf_singleton] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 383,
"column": 17
} | {
"line": 383,
"column": 50
} | [
{
"pp": "case singleton\nα : Type u_2\nι : Type u_5\ninst✝ : BooleanAlgebra α\ns : Finset ι\nf : ι → α\na : α\na✝ : ι\n⊢ ({a✝}.inf fun b ↦ a \\ f b) = a \\ {a✝}.sup f",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"congrArg",
"Finset.sup_singleton",
"Finset",
... | rw [sup_singleton, inf_singleton] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Powerset | {
"line": 299,
"column": 2
} | {
"line": 299,
"column": 43
} | [
{
"pp": "α : Type u_1\ns : Multiset α\n⊢ powersetCard s.card s = {s}",
"usedConstants": [
"Multiset.powersetCard_zero_left",
"Multiset.map",
"congrArg",
"Membership.mem",
"Multiset.powersetCard_cons",
"Multiset",
"Multiset.cons",
"instOfNatNat",
"Nat.lt_... | induction s using Multiset.induction with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 481,
"column": 8
} | {
"line": 481,
"column": 58
} | [
{
"pp": "case insert.inr.inr\nα : Type u_2\nι : Type u_5\ninst✝¹ : LinearOrder α\ninst✝ : OrderBot α\ns✝ : Finset ι\nf : ι → α\na : ι\ns : Finset ι\na✝ : a ∉ s\nh : s.Nonempty → s.sup f ∈ f '' ↑s\nhs✝ : (insert a s).Nonempty\nhs : s.Nonempty\nha : s.sup f ≤ f a\n⊢ f a ∈ f '' insert a ↑s",
"usedConstants": [... | apply Set.mem_image_of_mem _ (Set.mem_insert a ↑s) | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.