module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.Data.List.Lattice | {
"line": 121,
"column": 2
} | {
"line": 121,
"column": 24
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nl : List α\n⊢ l ∩ [] = []",
"usedConstants": [
"List.rec",
"instBEqOfDecidableEq",
"Inter.inter",
"List",
"List.instInterOfBEq_batteries",
"_private.Mathlib.Data.List.Lattice.0.List.inter_nil'._proof_1_2",
"Eq",
"L... | induction l with grind | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Lattice | {
"line": 121,
"column": 2
} | {
"line": 121,
"column": 24
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nl : List α\n⊢ l ∩ [] = []",
"usedConstants": [
"List.rec",
"instBEqOfDecidableEq",
"Inter.inter",
"List",
"List.instInterOfBEq_batteries",
"_private.Mathlib.Data.List.Lattice.0.List.inter_nil'._proof_1_2",
"Eq",
"L... | induction l with grind | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Lattice | {
"line": 261,
"column": 31
} | {
"line": 261,
"column": 44
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nhead✝ : α\ntail✝ : List α\nih : ∀ {l₂ : List α}, tail✝.bagInter l₂ <+ tail✝ ∩ l₂\nl₂ : List α\nh✝ : head✝ ∈ l₂\n⊢ head✝ ∈ l₂",
"usedConstants": []
}
] | by assumption | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Multiset.UnionInter | {
"line": 131,
"column": 4
} | {
"line": 131,
"column": 69
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : Multiset α\na : α\nx✝ : a ∈ s ∧ a ∈ t\nh₁ : a ∈ s\nh₂ : a ∈ t\n⊢ a ∈ s ∩ t",
"usedConstants": [
"Eq.mpr",
"Multiset.instInter",
"congrArg",
"Membership.mem",
"Multiset",
"Multiset.cons",
"id",
"Multiset.cons_... | rw [← cons_erase h₁, cons_inter_of_pos _ h₂]; apply mem_cons_self | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Multiset.UnionInter | {
"line": 131,
"column": 4
} | {
"line": 131,
"column": 69
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : Multiset α\na : α\nx✝ : a ∈ s ∧ a ∈ t\nh₁ : a ∈ s\nh₂ : a ∈ t\n⊢ a ∈ s ∩ t",
"usedConstants": [
"Eq.mpr",
"Multiset.instInter",
"congrArg",
"Membership.mem",
"Multiset",
"Multiset.cons",
"id",
"Multiset.cons_... | rw [← cons_erase h₁, cons_inter_of_pos _ h₂]; apply mem_cons_self | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Filter | {
"line": 429,
"column": 2
} | {
"line": 430,
"column": 67
} | [
{
"pp": "α : Type u_1\ns : Multiset α\np : { a // a ∈ s } → Prop\ninst✝¹ : DecidableEq α\ninst✝ : DecidablePred p\n⊢ filter (fun b ↦ ∃ a, p a ∧ ↑a = b) (map val s.attach) =\n map val (map (Subtype.map id ⋯) (filter (fun x ↦ ∃ h, p ⟨x, h⟩) s).attach)",
"usedConstants": [
"Iff.mpr",
"Subtype.ma... | simp only [Function.comp, Subtype.exists, Subtype.map,
exists_and_right, exists_eq_right, attach_map_val, map_map, id] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Finset.Lattice.Basic | {
"line": 240,
"column": 2
} | {
"line": 240,
"column": 43
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : Finset α\n⊢ s ∩ (t ∪ s) = s",
"usedConstants": [
"Eq.mpr",
"Finset.instUnion",
"congrArg",
"Finset",
"Finset.inter_comm",
"id",
"Inter.inter",
"Finset.instInter",
"Eq.refl",
"Union.union",
"... | rw [inter_comm, union_inter_cancel_right] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Finset.Lattice.Basic | {
"line": 240,
"column": 2
} | {
"line": 240,
"column": 43
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : Finset α\n⊢ s ∩ (t ∪ s) = s",
"usedConstants": [
"Eq.mpr",
"Finset.instUnion",
"congrArg",
"Finset",
"Finset.inter_comm",
"id",
"Inter.inter",
"Finset.instInter",
"Eq.refl",
"Union.union",
"... | rw [inter_comm, union_inter_cancel_right] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Lattice.Basic | {
"line": 240,
"column": 2
} | {
"line": 240,
"column": 43
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns t : Finset α\n⊢ s ∩ (t ∪ s) = s",
"usedConstants": [
"Eq.mpr",
"Finset.instUnion",
"congrArg",
"Finset",
"Finset.inter_comm",
"id",
"Inter.inter",
"Finset.instInter",
"Eq.refl",
"Union.union",
"... | rw [inter_comm, union_inter_cancel_right] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Image | {
"line": 634,
"column": 51
} | {
"line": 636,
"column": 11
} | [
{
"pp": "α : Type u_1\np : α → Prop\ns : Finset { x // p x }\na : α\nh : a ∈ map (Embedding.subtype fun x ↦ p x) s\n⊢ p a",
"usedConstants": [
"Finset",
"Finset.map",
"Membership.mem",
"Exists",
"Subtype",
"Function.Embedding",
"And.casesOn",
"And",
"Exi... | by
rcases mem_map.1 h with ⟨x, _, rfl⟩
exact x.2 | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Fin.SuccPred | {
"line": 382,
"column": 2
} | {
"line": 382,
"column": 52
} | [
{
"pp": "n : ℕ\nj : Fin n\ni : Fin (n + 1)\nhi : i ≠ last n\n⊢ i.castPred hi ≤ j ↔ i ≤ j.castSucc",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Iff.rfl",
"id",
"Fin.castPred",
"instOfNatNat",
"LE.le",
"instLEFin",
"instHAdd",
"Iff",
"HAdd.hAdd"... | rw [← castSucc_le_castSucc_iff, castSucc_castPred] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Fin.SuccPred | {
"line": 382,
"column": 2
} | {
"line": 382,
"column": 52
} | [
{
"pp": "n : ℕ\nj : Fin n\ni : Fin (n + 1)\nhi : i ≠ last n\n⊢ i.castPred hi ≤ j ↔ i ≤ j.castSucc",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Iff.rfl",
"id",
"Fin.castPred",
"instOfNatNat",
"LE.le",
"instLEFin",
"instHAdd",
"Iff",
"HAdd.hAdd"... | rw [← castSucc_le_castSucc_iff, castSucc_castPred] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.SuccPred | {
"line": 382,
"column": 2
} | {
"line": 382,
"column": 52
} | [
{
"pp": "n : ℕ\nj : Fin n\ni : Fin (n + 1)\nhi : i ≠ last n\n⊢ i.castPred hi ≤ j ↔ i ≤ j.castSucc",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Iff.rfl",
"id",
"Fin.castPred",
"instOfNatNat",
"LE.le",
"instLEFin",
"instHAdd",
"Iff",
"HAdd.hAdd"... | rw [← castSucc_le_castSucc_iff, castSucc_castPred] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fin.SuccPred | {
"line": 386,
"column": 2
} | {
"line": 386,
"column": 52
} | [
{
"pp": "n : ℕ\nj : Fin n\ni : Fin (n + 1)\nhi : i ≠ last n\n⊢ j ≤ i.castPred hi ↔ j.castSucc ≤ i",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Iff.rfl",
"id",
"Fin.castPred",
"instOfNatNat",
"LE.le",
"instLEFin",
"instHAdd",
"Iff",
"HAdd.hAdd"... | rw [← castSucc_le_castSucc_iff, castSucc_castPred] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Fin.SuccPred | {
"line": 386,
"column": 2
} | {
"line": 386,
"column": 52
} | [
{
"pp": "n : ℕ\nj : Fin n\ni : Fin (n + 1)\nhi : i ≠ last n\n⊢ j ≤ i.castPred hi ↔ j.castSucc ≤ i",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Iff.rfl",
"id",
"Fin.castPred",
"instOfNatNat",
"LE.le",
"instLEFin",
"instHAdd",
"Iff",
"HAdd.hAdd"... | rw [← castSucc_le_castSucc_iff, castSucc_castPred] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.SuccPred | {
"line": 386,
"column": 2
} | {
"line": 386,
"column": 52
} | [
{
"pp": "n : ℕ\nj : Fin n\ni : Fin (n + 1)\nhi : i ≠ last n\n⊢ j ≤ i.castPred hi ↔ j.castSucc ≤ i",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Iff.rfl",
"id",
"Fin.castPred",
"instOfNatNat",
"LE.le",
"instLEFin",
"instHAdd",
"Iff",
"HAdd.hAdd"... | rw [← castSucc_le_castSucc_iff, castSucc_castPred] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fin.SuccPred | {
"line": 786,
"column": 2
} | {
"line": 786,
"column": 37
} | [
{
"pp": "case neg\nn : ℕ\ninst✝ : NeZero n\ni : Fin (n + 1)\nhi : ¬i = 0\n⊢ predAbove 0 i = i.pred hi",
"usedConstants": [
"Eq.mpr",
"Fin.pred",
"congrArg",
"id",
"Fin.instOfNat",
"Fin.predAbove_zero_of_ne_zero",
"Fin.predAbove",
"Eq.refl",
"OfNat.ofNat"... | · rw [predAbove_zero_of_ne_zero hi] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 184,
"column": 15
} | {
"line": 184,
"column": 37
} | [
{
"pp": "m n : ℕ\nα : Fin (n + 1) → Sort u\nx✝ : α 0\nq : (i : Fin (n + 1)) → α i\np : (i : Fin n) → α i.succ\ni : Fin n\ny : α i.succ\nz : α 0\nmotive : ((i : Fin n.succ) → α i) → Sort v\ncons : (x₀ : α 0) → (x : (i : Fin n) → α i.succ) → motive (Fin.cons x₀ x)\nx : (i : Fin n.succ) → α i\n⊢ motive (Fin.cons (... | by rw [cons_self_tail] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.Card | {
"line": 870,
"column": 4
} | {
"line": 872,
"column": 37
} | [
{
"pp": "case inr\nα : Type u_1\np : (s : Finset α) → s.Nonempty → Prop\nh₀ : ∀ (a : α), p {a} ⋯\nh₁ : ∀ ⦃s : Finset α⦄ (hs : s.Nontrivial), (∀ (t : Finset α) (ht : t.Nonempty), t ⊂ s → p t ht) → p s ⋯\ns : Finset α\nhs✝ : s.Nonempty\nhs : s.Nontrivial\n⊢ p s hs✝",
"usedConstants": [
"Finset",
"... | · refine h₁ hs fun t ht hts ↦ ?_
have := card_lt_card hts
exact ht.strong_induction h₀ h₁ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 630,
"column": 6
} | {
"line": 630,
"column": 20
} | [
{
"pp": "case h.succ.cast\nn : ℕ\nβ : Sort u_2\na : β\nq : Fin n → β\nb : β\nj : Fin n\n⊢ cons a (snoc q b) j.castSucc.succ = snoc (cons a q) b j.castSucc.succ",
"usedConstants": [
"Eq.mpr",
"Fin.cons_succ",
"Fin.succ",
"congrArg",
"Fin.cons",
"Fin.snoc",
"id",
... | rw [cons_succ] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 759,
"column": 2
} | {
"line": 762,
"column": 45
} | [
{
"pp": "case refine_2\nn : ℕ\nα : Type u_2\nx₀ : α\nx : Fin n → α\nh : Injective (snoc x x₀)\n⊢ ¬x₀ ∈ Set.range x",
"usedConstants": [
"False",
"Fin.snoc_castSucc",
"congrArg",
"Function.Injective.eq_iff",
"Membership.mem",
"Eq.mp",
"Fin.snoc",
"instOfNatNat"... | · rintro ⟨i, hi⟩
rw [← @snoc_last n (fun i ↦ α) x₀ x, ← @snoc_castSucc n (fun i ↦ α) x₀ x i,
h.eq_iff] at hi
exact ne_last_of_lt i.castSucc_lt_last hi | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1273,
"column": 4
} | {
"line": 1273,
"column": 61
} | [
{
"pp": "case inr.inr\nn : ℕ\nα : Sort u_1\nj : Fin (n + 1)\nop : α → α → α\ng : Fin (n + 1) → α\nk : Fin n\nhjk : ↑j ≠ ↑k\nh : ↑j < ↑k\n⊢ j.contractNth op g k = g (j.succAbove k)",
"usedConstants": [
"Fin.succAbove_of_le_castSucc",
"Fin.succAbove",
"Eq.mpr",
"Fin.succ",
"congr... | rwa [j.succAbove_of_le_castSucc, contractNth_apply_of_gt] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Data.List.Flatten | {
"line": 38,
"column": 2
} | {
"line": 38,
"column": 24
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nl : List α\nf g : α → List β\nh : ∀ (a : α), a ∈ l → f a <+ g a\n⊢ flatMap f l <+ flatMap g l",
"usedConstants": [
"_private.Mathlib.Data.List.Flatten.0.List.Sublist.flatMap_right._proof_1_2",
"Membership.mem",
"_private.Mathlib.Data.List.Flatten.0.List... | induction l with grind | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.List.Flatten | {
"line": 38,
"column": 2
} | {
"line": 38,
"column": 24
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nl : List α\nf g : α → List β\nh : ∀ (a : α), a ∈ l → f a <+ g a\n⊢ flatMap f l <+ flatMap g l",
"usedConstants": [
"_private.Mathlib.Data.List.Flatten.0.List.Sublist.flatMap_right._proof_1_2",
"Membership.mem",
"_private.Mathlib.Data.List.Flatten.0.List... | induction l with grind | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Flatten | {
"line": 38,
"column": 2
} | {
"line": 38,
"column": 24
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nl : List α\nf g : α → List β\nh : ∀ (a : α), a ∈ l → f a <+ g a\n⊢ flatMap f l <+ flatMap g l",
"usedConstants": [
"_private.Mathlib.Data.List.Flatten.0.List.Sublist.flatMap_right._proof_1_2",
"Membership.mem",
"_private.Mathlib.Data.List.Flatten.0.List... | induction l with grind | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Pairwise | {
"line": 49,
"column": 2
} | {
"line": 49,
"column": 33
} | [
{
"pp": "α : Type u_1\nR : α → α → Prop\nl : List α\nhR : Symmetric R\nhl : Pairwise R l\n⊢ ∀ ⦃a : α⦄, a ∈ l → ∀ ⦃b : α⦄, b ∈ l → a ≠ b → R a b",
"usedConstants": [
"Ne",
"List.Pairwise.forall_of_forall"
]
}
] | apply Pairwise.forall_of_forall | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.List.Pairwise | {
"line": 104,
"column": 44
} | {
"line": 104,
"column": 57
} | [
{
"pp": "α : Type u_1\nR : α → α → Prop\na : α\ninst✝¹ : Inhabited α\ninst✝ : Std.Refl R\nhead✝ : α\ntail✝ : List α\nh : Pairwise R (head✝ :: tail✝)\na✝ : Mem a tail✝\n⊢ a ∈ tail✝",
"usedConstants": []
}
] | by assumption | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.Fold | {
"line": 155,
"column": 6
} | {
"line": 156,
"column": 10
} | [
{
"pp": "case insert\nα : 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 : β\na : α\ns : Finset α\nha : a ∉ s\nIH : r c (fold op b f s) ↔ r c b ∧ ∀ x ∈ s, r c (f x)\... | rw [Finset.fold_insert ha, hr, IH, ← and_assoc, @and_comm (r c (f a)), and_assoc]
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Fold | {
"line": 155,
"column": 6
} | {
"line": 156,
"column": 10
} | [
{
"pp": "case insert\nα : 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 : β\na : α\ns : Finset α\nha : a ∉ s\nIH : r c (fold op b f s) ↔ r c b ∧ ∀ x ∈ s, r c (f x)\... | rw [Finset.fold_insert ha, hr, IH, ← and_assoc, @and_comm (r c (f a)), and_assoc]
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.Finite.Basic | {
"line": 923,
"column": 38
} | {
"line": 923,
"column": 49
} | [
{
"pp": "α : Type u\nβ : Type v\ninst✝ : DecidableEq β\nf : α → β\ns : Set α\nt : Finset β\nhfs : SurjOn f s ↑t\nu : Set α\nhus : u ⊆ s\nhf : InjOn f u\nhimg : f '' u = ↑t\n⊢ (f '' u).Finite",
"usedConstants": [
"congrArg",
"Finset",
"Set.Finite",
"SetLike.coe",
"Finset.instSet... | simp [himg] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Set.Finite.Basic | {
"line": 923,
"column": 38
} | {
"line": 923,
"column": 49
} | [
{
"pp": "α : Type u\nβ : Type v\ninst✝ : DecidableEq β\nf : α → β\ns : Set α\nt : Finset β\nhfs : SurjOn f s ↑t\nu : Set α\nhus : u ⊆ s\nhf : InjOn f u\nhimg : f '' u = ↑t\n⊢ (f '' u).Finite",
"usedConstants": [
"congrArg",
"Finset",
"Set.Finite",
"SetLike.coe",
"Finset.instSet... | simp [himg] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Finite.Basic | {
"line": 923,
"column": 38
} | {
"line": 923,
"column": 49
} | [
{
"pp": "α : Type u\nβ : Type v\ninst✝ : DecidableEq β\nf : α → β\ns : Set α\nt : Finset β\nhfs : SurjOn f s ↑t\nu : Set α\nhus : u ⊆ s\nhf : InjOn f u\nhimg : f '' u = ↑t\n⊢ (f '' u).Finite",
"usedConstants": [
"congrArg",
"Finset",
"Set.Finite",
"SetLike.coe",
"Finset.instSet... | simp [himg] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Rotate | {
"line": 135,
"column": 2
} | {
"line": 135,
"column": 64
} | [
{
"pp": "case inr\nα : Type u\nl : List α\nn : ℕ\nhl : 0 < l.length\n⊢ l.rotate n = drop (n % l.length) l ++ take (n % l.length) l",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.rotate_mod",
"id",
"LT.lt.le",
"Nat.instMod",
"instHMod",
"Nat.mod_lt",
"i... | rw [← rotate_eq_drop_append_take (n.mod_lt hl).le, rotate_mod] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 62,
"column": 2
} | {
"line": 62,
"column": 33
} | [
{
"pp": "M : Type u_4\ninst✝ : Monoid M\nl₁ l₂ : List M\nh : l₁ ~ l₂\nhc : Pairwise Commute l₁\n⊢ ∀ (x : M), x ∈ l₁ → ∀ (y : M), y ∈ l₁ → ∀ (z : M), y * (x * z) = x * (y * z)",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"MulOne.toMul",
"List.Pairwise.forall_of_forall",
... | apply Pairwise.forall_of_forall | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.BigOperators.Group.Multiset.Basic | {
"line": 124,
"column": 53
} | {
"line": 124,
"column": 62
} | [
{
"pp": "ι : Type u_2\nκ : Type u_3\nM : Type u_5\ninst✝ : CommMonoid M\nm✝ : Multiset ι\nn : Multiset κ\nf : ι → κ → M\na : ι\nm : Multiset ι\nih : (map (fun a ↦ (map (fun b ↦ f a b) n).prod) m).prod = (map (fun b ↦ (map (fun a ↦ f a b) m).prod) n).prod\n⊢ (map (fun a ↦ (map (fun b ↦ f a b) n).prod) (a ::ₘ m))... | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.BigOperators.Group.Multiset.Basic | {
"line": 124,
"column": 53
} | {
"line": 124,
"column": 62
} | [
{
"pp": "ι : Type u_2\nκ : Type u_3\nM : Type u_5\ninst✝ : CommMonoid M\nm✝ : Multiset ι\nn : Multiset κ\nf : ι → κ → M\na : ι\nm : Multiset ι\nih : (map (fun a ↦ (map (fun b ↦ f a b) n).prod) m).prod = (map (fun b ↦ (map (fun a ↦ f a b) m).prod) n).prod\n⊢ (map (fun a ↦ (map (fun b ↦ f a b) n).prod) (a ::ₘ m))... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.Multiset.Basic | {
"line": 124,
"column": 53
} | {
"line": 124,
"column": 62
} | [
{
"pp": "ι : Type u_2\nκ : Type u_3\nM : Type u_5\ninst✝ : CommMonoid M\nm✝ : Multiset ι\nn : Multiset κ\nf : ι → κ → M\na : ι\nm : Multiset ι\nih : (map (fun a ↦ (map (fun b ↦ f a b) n).prod) m).prod = (map (fun b ↦ (map (fun a ↦ f a b) m).prod) n).prod\n⊢ (map (fun a ↦ (map (fun b ↦ f a b) n).prod) (a ::ₘ m))... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 166,
"column": 2
} | {
"line": 168,
"column": 25
} | [
{
"pp": "M : Type u_4\ninst✝ : CommMonoid M\nl₁ l₂ : List M\nh : l₁ <+ l₂\n⊢ l₁.prod ∣ l₂.prod",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Dvd.dvd",
"List.prod_append",
"HMul.hMul",
"Semigroup.to_isAssociative",
"Monoid.toMulOneClass",
"congrArg",
"L... | obtain ⟨l, hl⟩ := h.exists_perm_append
rw [hl.prod_eq, prod_append]
exact dvd_mul_right _ _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 166,
"column": 2
} | {
"line": 168,
"column": 25
} | [
{
"pp": "M : Type u_4\ninst✝ : CommMonoid M\nl₁ l₂ : List M\nh : l₁ <+ l₂\n⊢ l₁.prod ∣ l₂.prod",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Dvd.dvd",
"List.prod_append",
"HMul.hMul",
"Semigroup.to_isAssociative",
"Monoid.toMulOneClass",
"congrArg",
"L... | obtain ⟨l, hl⟩ := h.exists_perm_append
rw [hl.prod_eq, prod_append]
exact dvd_mul_right _ _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Rotate | {
"line": 437,
"column": 2
} | {
"line": 437,
"column": 38
} | [
{
"pp": "α : Type u\nl : List α\nn : ℕ\n⊢ l.reverse ~r (l.rotate n).reverse",
"usedConstants": [
"HSub.hSub",
"List.reverse_rotate",
"Nat.instMod",
"instHMod",
"instSubNat",
"List",
"HMod.hMod",
"instHSub",
"Nat",
"Exists.intro",
"List.revers... | exact ⟨_, (reverse_rotate _ _).symm⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.List.Rotate | {
"line": 439,
"column": 74
} | {
"line": 442,
"column": 27
} | [
{
"pp": "α : Type u\nl l' : List α\n⊢ l.reverse ~r l' ↔ l ~r l'.reverse",
"usedConstants": [
"List.IsRotated.reverse",
"congrArg",
"Eq.mp",
"List.IsRotated",
"List",
"List.reverse_reverse",
"Iff.intro",
"List.reverse",
"congrFun'"
]
}
] | by
constructor <;>
· intro h
simpa using h.reverse | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Multiset.Bind | {
"line": 77,
"column": 19
} | {
"line": 77,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type v\nf : α → β\na✝ : Multiset α\ns✝ : Multiset (Multiset α)\nih : map f s✝.join = (map (map f) s✝).join\n⊢ map f (a✝ ::ₘ s✝).join = (map (map f) (a✝ ::ₘ s✝)).join",
"usedConstants": [
"Multiset.map_cons",
"Multiset.map",
"congrArg",
"Membershi... | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Multiset.Bind | {
"line": 77,
"column": 19
} | {
"line": 77,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type v\nf : α → β\na✝ : Multiset α\ns✝ : Multiset (Multiset α)\nih : map f s✝.join = (map (map f) s✝).join\n⊢ map f (a✝ ::ₘ s✝).join = (map (map f) (a✝ ::ₘ s✝)).join",
"usedConstants": [
"Multiset.map_cons",
"Multiset.map",
"congrArg",
"Membershi... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Multiset.Bind | {
"line": 77,
"column": 19
} | {
"line": 77,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type v\nf : α → β\na✝ : Multiset α\ns✝ : Multiset (Multiset α)\nih : map f s✝.join = (map (map f) s✝).join\n⊢ map f (a✝ ::ₘ s✝).join = (map (map f) (a✝ ::ₘ s✝)).join",
"usedConstants": [
"Multiset.map_cons",
"Multiset.map",
"congrArg",
"Membershi... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Bind | {
"line": 84,
"column": 19
} | {
"line": 84,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\ninst✝ : CommMonoid α\na✝ : Multiset α\ns✝ : Multiset (Multiset α)\nih : s✝.join.prod = (map prod s✝).prod\n⊢ (a✝ ::ₘ s✝).join.prod = (map prod (a✝ ::ₘ s✝)).prod",
"usedConstants": [
"HMul.hMul",
"Multiset.map_cons",
"Multiset.map",
"Monoid.toMulOneCl... | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Multiset.Bind | {
"line": 84,
"column": 19
} | {
"line": 84,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\ninst✝ : CommMonoid α\na✝ : Multiset α\ns✝ : Multiset (Multiset α)\nih : s✝.join.prod = (map prod s✝).prod\n⊢ (a✝ ::ₘ s✝).join.prod = (map prod (a✝ ::ₘ s✝)).prod",
"usedConstants": [
"HMul.hMul",
"Multiset.map_cons",
"Multiset.map",
"Monoid.toMulOneCl... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Multiset.Bind | {
"line": 84,
"column": 19
} | {
"line": 84,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\ninst✝ : CommMonoid α\na✝ : Multiset α\ns✝ : Multiset (Multiset α)\nih : s✝.join.prod = (map prod s✝).prod\n⊢ (a✝ ::ₘ s✝).join.prod = (map prod (a✝ ::ₘ s✝)).prod",
"usedConstants": [
"HMul.hMul",
"Multiset.map_cons",
"Multiset.map",
"Monoid.toMulOneCl... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Bind | {
"line": 95,
"column": 19
} | {
"line": 95,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\np : α → Prop\ninst✝ : DecidablePred p\na✝ : Multiset α\ns✝ : Multiset (Multiset α)\nih : filter p s✝.join = (map (filter p) s✝).join\n⊢ filter p (a✝ ::ₘ s✝).join = (map (filter p) (a✝ ::ₘ s✝)).join",
"usedConstants": [
"Multiset.map_cons",
"Multiset.map",
... | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Multiset.Bind | {
"line": 95,
"column": 19
} | {
"line": 95,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\np : α → Prop\ninst✝ : DecidablePred p\na✝ : Multiset α\ns✝ : Multiset (Multiset α)\nih : filter p s✝.join = (map (filter p) s✝).join\n⊢ filter p (a✝ ::ₘ s✝).join = (map (filter p) (a✝ ::ₘ s✝)).join",
"usedConstants": [
"Multiset.map_cons",
"Multiset.map",
... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Multiset.Bind | {
"line": 95,
"column": 19
} | {
"line": 95,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\np : α → Prop\ninst✝ : DecidablePred p\na✝ : Multiset α\ns✝ : Multiset (Multiset α)\nih : filter p s✝.join = (map (filter p) s✝).join\n⊢ filter p (a✝ ::ₘ s✝).join = (map (filter p) (a✝ ::ₘ s✝)).join",
"usedConstants": [
"Multiset.map_cons",
"Multiset.map",
... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Bind | {
"line": 101,
"column": 19
} | {
"line": 101,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type v\nf : α → Option β\na✝ : Multiset α\ns✝ : Multiset (Multiset α)\nih : filterMap f s✝.join = (map (filterMap f) s✝).join\n⊢ filterMap f (a✝ ::ₘ s✝).join = (map (filterMap f) (a✝ ::ₘ s✝)).join",
"usedConstants": [
"Multiset.filterMap",
"Multiset.map_cons... | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Multiset.Bind | {
"line": 101,
"column": 19
} | {
"line": 101,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type v\nf : α → Option β\na✝ : Multiset α\ns✝ : Multiset (Multiset α)\nih : filterMap f s✝.join = (map (filterMap f) s✝).join\n⊢ filterMap f (a✝ ::ₘ s✝).join = (map (filterMap f) (a✝ ::ₘ s✝)).join",
"usedConstants": [
"Multiset.filterMap",
"Multiset.map_cons... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Multiset.Bind | {
"line": 101,
"column": 19
} | {
"line": 101,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type v\nf : α → Option β\na✝ : Multiset α\ns✝ : Multiset (Multiset α)\nih : filterMap f s✝.join = (map (filterMap f) s✝).join\n⊢ filterMap f (a✝ ::ₘ s✝).join = (map (filterMap f) (a✝ ::ₘ s✝)).join",
"usedConstants": [
"Multiset.filterMap",
"Multiset.map_cons... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Bind | {
"line": 317,
"column": 76
} | {
"line": 318,
"column": 29
} | [
{
"pp": "α : Type u_1\nβ : Type v\nb : β\ns : Multiset α\nt : Multiset β\n⊢ s ×ˢ (b ::ₘ t) = map (fun a ↦ (a, b)) s + s ×ˢ t",
"usedConstants": [
"Multiset.map_cons",
"Multiset.map",
"Multiset.instSProd",
"SProd.sprod",
"congrArg",
"Multiset",
"Multiset.cons",
... | by
simp [SProd.sprod, product] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Multiset.Bind | {
"line": 325,
"column": 92
} | {
"line": 326,
"column": 29
} | [
{
"pp": "α : Type u_1\nβ : Type v\ns t : Multiset α\nu : Multiset β\n⊢ (s + t) ×ˢ u = s ×ˢ u + t ×ˢ u",
"usedConstants": [
"Multiset.map",
"Multiset.instSProd",
"SProd.sprod",
"congrArg",
"Multiset",
"Prod.mk",
"instHAdd",
"Multiset.add_bind",
"HAdd.hAdd... | by
simp [SProd.sprod, product] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finite.Prod | {
"line": 176,
"column": 4
} | {
"line": 176,
"column": 30
} | [
{
"pp": "case refine_2.inr\nα : Type u_1\nβ : Type u_2\ns : Set α\nt : Set β\nh : t.Infinite ∧ s.Nonempty\n⊢ (s ×ˢ t).Infinite",
"usedConstants": [
"Set.Infinite.prod_right",
"Set.Nonempty",
"And.right",
"And.left",
"Set.Infinite"
]
}
] | · exact h.1.prod_right h.2 | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Group.Action.Hom | {
"line": 74,
"column": 2
} | {
"line": 74,
"column": 62
} | [
{
"pp": "E : Type u_4\nF : Type u_5\nG : Type u_6\ninst✝³ : Monoid E\ninst✝² : Monoid F\ninst✝¹ : MulAction F G\ninst✝ : IsPretransitive F G\nf : E →* F\nhf : Surjective ⇑f\nx✝ : MulAction E G := compHom G f\nx y : G\n⊢ ∃ g, g • x = y",
"usedConstants": [
"Monoid.toSemigroup",
"SemigroupAction.t... | obtain ⟨m, rfl⟩ : ∃ m : F, m • x = y := exists_smul_eq F x y | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Set.Lattice.Image | {
"line": 225,
"column": 4
} | {
"line": 225,
"column": 12
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nι : Sort u_5\ninst✝ : Nonempty ι\ns : ι → Set α\nf : α → β\nh : InjOn f (⋃ i, s i)\ninhabited_h : Inhabited ι\ny : β\nx : ι → α\nhx : ∀ (i : ι), x i ∈ s i\nhy : ∀ (i : ι), f (x i) = y\ni : ι\nthis : x default = x i\n⊢ x i ∈ s i",
"usedConstants": []
}
] | apply hx | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.Group.Pointwise.Set.Basic | {
"line": 743,
"column": 2
} | {
"line": 743,
"column": 70
} | [
{
"pp": "α : Type u_2\ninst✝¹ : Mul α\ninst✝ : IsRightCancelMul α\ns t : Set α\na : α\nha : a ∈ s\nb : α\nhb : b ∈ s\nhab : a ≠ b\nc : α\nhc : c ∈ t\n⊢ (s * t).Nontrivial",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"Membership.mem",
"Exists",
"id",
"Ne",... | exact ⟨a * c, mul_mem_mul ha hc, b * c, mul_mem_mul hb hc, by simpa⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Group.Submonoid.Basic | {
"line": 294,
"column": 48
} | {
"line": 294,
"column": 56
} | [
{
"pp": "M : Type u_1\ninst✝ : MulOneClass M\np₁ p₂ : Submonoid M\n⊢ (∀ ⦃x : M⦄, x ∈ p₁ ⊓ p₂ → x ∈ ⊥) ↔ ∀ {x : M}, x ∈ p₁ → x ∈ p₂ → x = 1",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"CompleteLattice.toLattice",
"congrArg",
"OrderBot.toBot",
"PartialOrder.toPreorder",
... | mem_inf, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Group.Subgroup.Lattice | {
"line": 557,
"column": 8
} | {
"line": 557,
"column": 29
} | [
{
"pp": "case hK\nG : Type u_1\ninst✝ : Group G\nι : Sort u_2\nhι : Nonempty ι\nK : ι → Subgroup G\nhK : Directed (fun x1 x2 ↦ x1 ≤ x2) K\nx : G\nthis : iSup K = ⨆ i, ⨆ (_ : True), K i.down\n⊢ DirectedOn ((fun x1 x2 ↦ x1 ≤ x2) on fun i ↦ K i.down) univ",
"usedConstants": [
"Eq.mpr",
"Function.on... | directedOn_onFun_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Submonoid.Operations | {
"line": 180,
"column": 42
} | {
"line": 180,
"column": 54
} | [
{
"pp": "M : Type u_1\nN : Type u_2\nP : Type u_3\ninst✝³ : MulOneClass M\ninst✝² : MulOneClass N\ninst✝¹ : MulOneClass P\nS✝ : Submonoid M\nF : Type u_4\ninst✝ : FunLike F M N\nmc : MonoidHomClass F M N\nf : F\nS : Submonoid N\na✝ b✝ : M\nha : a✝ ∈ ⇑f ⁻¹' ↑S\nhb : b✝ ∈ ⇑f ⁻¹' ↑S\n⊢ f (a✝ * b✝) ∈ S",
"usedC... | rw [map_mul] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Submonoid.Operations | {
"line": 208,
"column": 38
} | {
"line": 208,
"column": 50
} | [
{
"pp": "M : Type u_1\nN : Type u_2\nP : Type u_3\ninst✝³ : MulOneClass M\ninst✝² : MulOneClass N\ninst✝¹ : MulOneClass P\nS✝ : Submonoid M\nF : Type u_4\ninst✝ : FunLike F M N\nmc : MonoidHomClass F M N\nf : F\nS : Submonoid M\nx : M\nhx : x ∈ ↑S\ny : M\nhy : y ∈ ↑S\n⊢ f (x * y) = f x * f y",
"usedConstant... | rw [map_mul] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Submonoid.Operations | {
"line": 208,
"column": 38
} | {
"line": 208,
"column": 50
} | [
{
"pp": "M : Type u_1\nN : Type u_2\nP : Type u_3\ninst✝³ : MulOneClass M\ninst✝² : MulOneClass N\ninst✝¹ : MulOneClass P\nS✝ : Submonoid M\nF : Type u_4\ninst✝ : FunLike F M N\nmc : MonoidHomClass F M N\nf : F\nS : Submonoid M\nx : M\nhx : x ∈ ↑S\ny : M\nhy : y ∈ ↑S\n⊢ f (x * y) = f x * f y",
"usedConstant... | rw [map_mul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Submonoid.Operations | {
"line": 208,
"column": 38
} | {
"line": 208,
"column": 50
} | [
{
"pp": "M : Type u_1\nN : Type u_2\nP : Type u_3\ninst✝³ : MulOneClass M\ninst✝² : MulOneClass N\ninst✝¹ : MulOneClass P\nS✝ : Submonoid M\nF : Type u_4\ninst✝ : FunLike F M N\nmc : MonoidHomClass F M N\nf : F\nS : Submonoid M\nx : M\nhx : x ∈ ↑S\ny : M\nhy : y ∈ ↑S\n⊢ f (x * y) = f x * f y",
"usedConstant... | rw [map_mul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Pairing | {
"line": 112,
"column": 79
} | {
"line": 124,
"column": 44
} | [
{
"pp": "a₁ a₂ b : ℕ\nh : a₁ < a₂\n⊢ pair a₁ b < pair a₂ b",
"usedConstants": [
"Eq.mpr",
"lt_of_le_of_lt",
"False",
"Preorder.toLT",
"HMul.hMul",
"eq_false",
"congrArg",
"PartialOrder.toPreorder",
"Nat.mul_self_le_mul_self",
"Nat.add_lt_add_of_le_... | by
by_cases h₁ : a₁ < b <;> simp only [pair, h₁, ↓reduceIte, Nat.add_assoc]
· by_cases h₂ : a₂ < b
· simp [h₂, h]
simp only [h₂, ↓reduceIte]
apply Nat.add_lt_add_of_le_of_lt
· exact Nat.mul_self_le_mul_self (not_lt.mp h₂)
· exact Nat.lt_add_right _ h
· simp at h₁
simp only [not_lt_of_gt (l... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Choose.Basic | {
"line": 243,
"column": 39
} | {
"line": 243,
"column": 82
} | [
{
"pp": "m n : ℕ\nhn : n ≠ 0\np : ℕ := n - 1\nhp : n = p + 1\n⊢ (m * (p + 1) + (p + 1)).choose (p + 1) * (m * (p + 1))! * (p + 1)! = (m * (p + 1) + (p + 1))!",
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"HMul.hMul",
"congrArg",
"id",
"instMulNat",
"instOfNatNat",
... | rw [add_choose_mul_factorial_mul_factorial] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Choose.Basic | {
"line": 243,
"column": 39
} | {
"line": 243,
"column": 82
} | [
{
"pp": "m n : ℕ\nhn : n ≠ 0\np : ℕ := n - 1\nhp : n = p + 1\n⊢ (m * (p + 1) + (p + 1)).choose (p + 1) * (m * (p + 1))! * (p + 1)! = (m * (p + 1) + (p + 1))!",
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"HMul.hMul",
"congrArg",
"id",
"instMulNat",
"instOfNatNat",
... | rw [add_choose_mul_factorial_mul_factorial] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Choose.Basic | {
"line": 243,
"column": 39
} | {
"line": 243,
"column": 82
} | [
{
"pp": "m n : ℕ\nhn : n ≠ 0\np : ℕ := n - 1\nhp : n = p + 1\n⊢ (m * (p + 1) + (p + 1)).choose (p + 1) * (m * (p + 1))! * (p + 1)! = (m * (p + 1) + (p + 1))!",
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"HMul.hMul",
"congrArg",
"id",
"instMulNat",
"instOfNatNat",
... | rw [add_choose_mul_factorial_mul_factorial] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Max | {
"line": 505,
"column": 4
} | {
"line": 505,
"column": 65
} | [
{
"pp": "case H.inr\nα : Type u_2\nι : Type u_5\ninst✝¹ : LinearOrder α\ninst✝ : DecidableEq ι\nf : ι → α\nmotive : Finset ι → Prop\nempty : motive ∅\ninsert : ∀ (a : ι) (s : Finset ι), a ∉ s → (∀ x ∈ s, f x ≤ f a) → motive s → motive (Insert.insert a s)\ns : Finset ι\nihs : ∀ s_1 ∈ s, motive (s.erase s_1)\nhne... | exact le_max' _ _ (mem_image_of_mem _ <| mem_of_mem_erase hx) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Nat.Choose.Basic | {
"line": 248,
"column": 6
} | {
"line": 248,
"column": 49
} | [
{
"pp": "m n : ℕ\nhn : n ≠ 0\np : ℕ := n - 1\nhp : n = p + 1\n⊢ (m * (p + 1) + p)! * ((p + 1) * (m + 1)) = (m * (p + 1) + p).choose p * (m * (p + 1))! * p ! * ((p + 1) * (m + 1))",
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"HMul.hMul",
"congrArg",
"id",
"instMulNat",
... | rw [add_choose_mul_factorial_mul_factorial] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Choose.Basic | {
"line": 248,
"column": 6
} | {
"line": 248,
"column": 49
} | [
{
"pp": "m n : ℕ\nhn : n ≠ 0\np : ℕ := n - 1\nhp : n = p + 1\n⊢ (m * (p + 1) + p)! * ((p + 1) * (m + 1)) = (m * (p + 1) + p).choose p * (m * (p + 1))! * p ! * ((p + 1) * (m + 1))",
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"HMul.hMul",
"congrArg",
"id",
"instMulNat",
... | rw [add_choose_mul_factorial_mul_factorial] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Choose.Basic | {
"line": 248,
"column": 6
} | {
"line": 248,
"column": 49
} | [
{
"pp": "m n : ℕ\nhn : n ≠ 0\np : ℕ := n - 1\nhp : n = p + 1\n⊢ (m * (p + 1) + p)! * ((p + 1) * (m + 1)) = (m * (p + 1) + p).choose p * (m * (p + 1))! * p ! * ((p + 1) * (m + 1))",
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"HMul.hMul",
"congrArg",
"id",
"instMulNat",
... | rw [add_choose_mul_factorial_mul_factorial] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Choose.Basic | {
"line": 272,
"column": 4
} | {
"line": 272,
"column": 11
} | [
{
"pp": "case zero\nk : ℕ\n⊢ ascFactorial 0 k = k ! * (0 + k - 1).choose k",
"usedConstants": [
"Nat",
"Eq.refl"
]
}
] | cases k | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Data.Nat.Choose.Basic | {
"line": 284,
"column": 2
} | {
"line": 286,
"column": 68
} | [
{
"pp": "n k : ℕ\n⊢ (n + k).choose k = (n + 1).ascFactorial k / k !",
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"instHDiv",
"HMul.hMul",
"Nat.factorial_dvd_ascFactorial",
"congrArg",
"Nat.mul_left_cancel",
"Nat.ascFactorial",
"id",
"HDiv.hDiv",
... | apply Nat.mul_left_cancel k.factorial_pos
rw [← ascFactorial_eq_factorial_mul_choose]
exact (Nat.mul_div_cancel' <| factorial_dvd_ascFactorial _ _).symm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Choose.Basic | {
"line": 284,
"column": 2
} | {
"line": 286,
"column": 68
} | [
{
"pp": "n k : ℕ\n⊢ (n + k).choose k = (n + 1).ascFactorial k / k !",
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"instHDiv",
"HMul.hMul",
"Nat.factorial_dvd_ascFactorial",
"congrArg",
"Nat.mul_left_cancel",
"Nat.ascFactorial",
"id",
"HDiv.hDiv",
... | apply Nat.mul_left_cancel k.factorial_pos
rw [← ascFactorial_eq_factorial_mul_choose]
exact (Nat.mul_div_cancel' <| factorial_dvd_ascFactorial _ _).symm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Choose.Basic | {
"line": 340,
"column": 4
} | {
"line": 341,
"column": 17
} | [
{
"pp": "case inr\nr n : ℕ\nb : n < r\n⊢ n.choose r ≤ n.choose (n / 2)",
"usedConstants": [
"Eq.mpr",
"Nat.zero_le",
"Nat.choose",
"instHDiv",
"congrArg",
"id",
"HDiv.hDiv",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat",
"Nat.choose_eq_ze... | rw [choose_eq_zero_of_lt b]
apply zero_le | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Choose.Basic | {
"line": 340,
"column": 4
} | {
"line": 341,
"column": 17
} | [
{
"pp": "case inr\nr n : ℕ\nb : n < r\n⊢ n.choose r ≤ n.choose (n / 2)",
"usedConstants": [
"Eq.mpr",
"Nat.zero_le",
"Nat.choose",
"instHDiv",
"congrArg",
"id",
"HDiv.hDiv",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat",
"Nat.choose_eq_ze... | rw [choose_eq_zero_of_lt b]
apply zero_le | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Choose.Basic | {
"line": 346,
"column": 67
} | {
"line": 347,
"column": 19
} | [
{
"pp": "a c : ℕ\n⊢ a.choose c ≤ a.succ.choose c",
"usedConstants": [
"Nat.choose",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat.casesAuxOn",
"instHAdd",
"HAdd.hAdd",
"Nat",
"_private.Mathlib.Data.Nat.Choose.Basic.0.Nat.choose_le_succ._proof_1_2",
"_... | by
cases c <;> grind | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 255,
"column": 12
} | {
"line": 255,
"column": 59
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝¹ : SemilatticeSup α\ninst✝ : OrderBot α\nf : β → α\nS : Finset β\n⊢ S.sup f = ⊥ ↔ ∀ s ∈ S, f s = ⊥",
"usedConstants": [
"False",
"Finset.sup_insert",
"congrArg",
"Finset",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"foral... | induction S using Finset.induction <;> simp [*] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 255,
"column": 12
} | {
"line": 255,
"column": 59
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝¹ : SemilatticeSup α\ninst✝ : OrderBot α\nf : β → α\nS : Finset β\n⊢ S.sup f = ⊥ ↔ ∀ s ∈ S, f s = ⊥",
"usedConstants": [
"False",
"Finset.sup_insert",
"congrArg",
"Finset",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"foral... | induction S using Finset.induction <;> simp [*] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 255,
"column": 12
} | {
"line": 255,
"column": 59
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝¹ : SemilatticeSup α\ninst✝ : OrderBot α\nf : β → α\nS : Finset β\n⊢ S.sup f = ⊥ ↔ ∀ s ∈ S, f s = ⊥",
"usedConstants": [
"False",
"Finset.sup_insert",
"congrArg",
"Finset",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"foral... | induction S using Finset.induction <;> simp [*] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Sublists | {
"line": 411,
"column": 4
} | {
"line": 413,
"column": 42
} | [
{
"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₂) ∈ (a :: l).sublists'.zip (a :: l).sublists'.reverse\n⊢ l₁ ++ l₂ ~ a :: l",
"usedConstants": [
"List.sublists'",
"congrArg",
... | rw [sublists'_cons, reverse_append, zip_append, ← map_reverse, zip_map_right, zip_map_left] at *
<;> [simp only [mem_append, mem_map, Prod.map_apply, id_eq, Prod.mk.injEq, Prod.exists,
exists_eq_right_right] at h; simp] | Batteries.Tactic._aux_Batteries_Tactic_SeqFocus___macroRules_Batteries_Tactic_seq_focus_1 | Batteries.Tactic.seq_focus |
Mathlib.Data.Multiset.Powerset | {
"line": 280,
"column": 4
} | {
"line": 280,
"column": 61
} | [
{
"pp": "α : Type u_1\nn : ℕ\ns : Multiset α\nl : List α\n⊢ List.map ofList (sublistsLen n l) <+~ List.map ofList l.sublists'",
"usedConstants": [
"List.sublists'",
"List.map",
"List.Sublist.map",
"Multiset",
"List.sublistsLen",
"List",
"Multiset.ofList",
"Lis... | exact ((sublistsLen_sublist_sublists' _ _).map _).subperm | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Multiset.Powerset | {
"line": 301,
"column": 19
} | {
"line": 301,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\na✝ : α\ns✝ : Multiset α\nih : powersetCard s✝.card s✝ = {s✝}\n⊢ powersetCard (a✝ ::ₘ s✝).card (a✝ ::ₘ s✝) = {a✝ ::ₘ s✝}",
"usedConstants": [
"Multiset.map",
"congrArg",
"Membership.mem",
"Multiset.powersetCard_cons",
"Multiset",
"Multiset... | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Multiset.Powerset | {
"line": 301,
"column": 19
} | {
"line": 301,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\na✝ : α\ns✝ : Multiset α\nih : powersetCard s✝.card s✝ = {s✝}\n⊢ powersetCard (a✝ ::ₘ s✝).card (a✝ ::ₘ s✝) = {a✝ ::ₘ s✝}",
"usedConstants": [
"Multiset.map",
"congrArg",
"Membership.mem",
"Multiset.powersetCard_cons",
"Multiset",
"Multiset... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Multiset.Powerset | {
"line": 301,
"column": 19
} | {
"line": 301,
"column": 28
} | [
{
"pp": "case cons\nα : Type u_1\na✝ : α\ns✝ : Multiset α\nih : powersetCard s✝.card s✝ = {s✝}\n⊢ powersetCard (a✝ ::ₘ s✝).card (a✝ ::ₘ s✝) = {a✝ ::ₘ s✝}",
"usedConstants": [
"Multiset.map",
"congrArg",
"Membership.mem",
"Multiset.powersetCard_cons",
"Multiset",
"Multiset... | simp [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Powerset | {
"line": 307,
"column": 31
} | {
"line": 307,
"column": 40
} | [
{
"pp": "case cons.zero\nα : Type u_1\nβ : Type u_2\nf : α → β\nt : α\ns : Multiset α\nih : ∀ (n : ℕ), powersetCard n (map f s) = map (map f) (powersetCard n s)\n⊢ powersetCard 0 (map f (t ::ₘ s)) = map (map f) (powersetCard 0 (t ::ₘ s))",
"usedConstants": [
"Multiset.powersetCard_zero_left",
"M... | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Multiset.Powerset | {
"line": 307,
"column": 31
} | {
"line": 307,
"column": 40
} | [
{
"pp": "case cons.succ\nα : Type u_1\nβ : Type u_2\nf : α → β\nt : α\ns : Multiset α\nih : ∀ (n : ℕ), powersetCard n (map f s) = map (map f) (powersetCard n s)\nn✝ : ℕ\n⊢ powersetCard (n✝ + 1) (map f (t ::ₘ s)) = map (map f) (powersetCard (n✝ + 1) (t ::ₘ s))",
"usedConstants": [
"Multiset.map_cons",
... | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Finset.Powerset | {
"line": 323,
"column": 2
} | {
"line": 325,
"column": 11
} | [
{
"pp": "case a\nα : Type u_1\ninst✝ : DecidableEq α\nu : Finset α\nn : ℕ\nhn : n < #u\n⊢ (powersetCard n.succ u).sup id ≤ u",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.Data.Finset.Powerset.0.Finset.powersetCard_sup._simp_1_1",
"Lattice.toSemilatticeSup",
"Finset",
"Partia... | · simp_rw [Finset.sup_le_iff, mem_powersetCard]
rintro x ⟨h, -⟩
exact h | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.ConditionallyCompleteLattice.Finset | {
"line": 66,
"column": 16
} | {
"line": 66,
"column": 29
} | [
{
"pp": "ι : Type u_1\nα : Type u_2\ninst✝ : ConditionallyCompleteLinearOrder α\nf : ι → α\ns : Finset ι\nh : ∃ x ∈ s, sSup ∅ ≤ f x\nh' : (image f s).Nonempty\ni : ι\nh✝ : i ∈ s\n⊢ i ∈ s",
"usedConstants": []
}
] | by assumption | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Set.Finite.Lattice | {
"line": 365,
"column": 2
} | {
"line": 365,
"column": 73
} | [
{
"pp": "ι : Type u_1\nι' : Type u_2\ninst✝¹ : LinearOrder ι'\ninst✝ : Nonempty ι'\nα : ι → Type u_3\nI : Set ι\ns : (i : ι) → ι' → Set (α i)\nhI : I.Finite\nhs : ∀ i ∈ I, Monotone (s i)\nthis : Finite ↑I\n⊢ ⋃ j, ⋂ x, eval ↑x ⁻¹' s (↑x) j = ⋂ x, ⋃ i, eval ↑x ⁻¹' s (↑x) i",
"usedConstants": [
"Lattice.... | refine iUnion_iInter_of_monotone (ι' := ι') (fun (i : I) j₁ j₂ h => ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Order.ConditionallyCompleteLattice.Indexed | {
"line": 370,
"column": 67
} | {
"line": 372,
"column": 34
} | [
{
"pp": "α : Type u_1\ninst✝ : ConditionallyCompleteLattice α\nι : Type u_5\nι' : Type u_6\ns : Set ι\nf : ι → ι'\ng : ι' → α\nhf : BddAbove (range fun i ↦ g (f ↑i))\nhg' : sSup ∅ ≤ ⨆ i, g (f ↑i)\nhs : s.Nonempty\nhg : BddAbove (range fun i ↦ g ↑i)\nthis : Nonempty ↑s\ni : ι\nh : i ∈ s\n⊢ ∃ t, g ↑t = g (f ↑⟨i, ... | by
have : f i ∈ f '' s := Set.mem_image_of_mem _ h
exact ⟨⟨f i, this⟩, by simp⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Cover | {
"line": 550,
"column": 2
} | {
"line": 550,
"column": 15
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : PartialOrder α\ninst✝ : PartialOrder β\na₁ a₂ : α\nb : β\nh : ∀ ⦃c : α⦄, a₁ < c → ¬c < a₂\nc : α × β\nh₁ : a₁ < c.1\nh₂ : c.1 < a₂\nthis : c.2 = b\n⊢ False",
"usedConstants": [
"Prod.fst"
]
}
] | exact h h₁ h₂ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.Interval.Multiset | {
"line": 64,
"column": 62
} | {
"line": 64,
"column": 66
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Preorder α\ninst✝ : LocallyFiniteOrder α\na b x : α\n⊢ x ∈ Ico a b ↔ a ≤ x ∧ x < b",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"Preorder.toLE",
"Membership.mem",
"Multiset",
"id",
"Finset.Ico",
"LE.le",
... | Ico, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Interval.Multiset | {
"line": 125,
"column": 6
} | {
"line": 125,
"column": 10
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Preorder α\ninst✝ : LocallyFiniteOrder α\na b : α\n⊢ Ico a b = 0 ↔ ¬a < b",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"Multiset",
"id",
"Finset.Ico",
"Finset.val",
"Multiset.Ico",
"Iff",
"LT.lt",
... | Ico, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Interval.Multiset | {
"line": 163,
"column": 41
} | {
"line": 163,
"column": 45
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Preorder α\ninst✝ : LocallyFiniteOrder α\na : α\n⊢ Ico a a = 0",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Multiset",
"id",
"Finset.Ico",
"Finset.val",
"Multiset.Ico",
"Zero.toOfNat0",
"OfNat.ofNat",
"Multiset.Ico.eq... | Ico, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Interval.Multiset | {
"line": 197,
"column": 6
} | {
"line": 197,
"column": 10
} | [
{
"pp": "α : Type u_1\ninst✝² : Preorder α\ninst✝¹ : LocallyFiniteOrder α\na b c : α\ninst✝ : DecidablePred fun x ↦ x < c\nhca : c ≤ a\n⊢ filter (fun x ↦ x < c) (Ico a b) = ∅",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"Multiset",
"id",
"Finset.Ico",
... | Ico, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Interval.Multiset | {
"line": 202,
"column": 6
} | {
"line": 202,
"column": 10
} | [
{
"pp": "α : Type u_1\ninst✝² : Preorder α\ninst✝¹ : LocallyFiniteOrder α\na b c : α\ninst✝ : DecidablePred fun x ↦ x < c\nhbc : b ≤ c\n⊢ filter (fun x ↦ x < c) (Ico a b) = Ico a b",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"Multiset",
"id",
"Finset.Ico",... | Ico, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Interval.Multiset | {
"line": 206,
"column": 6
} | {
"line": 206,
"column": 10
} | [
{
"pp": "α : Type u_1\ninst✝² : Preorder α\ninst✝¹ : LocallyFiniteOrder α\na b c : α\ninst✝ : DecidablePred fun x ↦ x < c\nhcb : c ≤ b\n⊢ filter (fun x ↦ x < c) (Ico a b) = Ico a c",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"Multiset",
"id",
"Finset.Ico",... | Ico, | Lean.Elab.Tactic.evalRewriteSeq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.