module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.Data.Fintype.Card | {
"line": 530,
"column": 2
} | {
"line": 530,
"column": 52
} | {
"line": 532,
"column": 0
} | [
{
"pp": "n : ℕ\ns : Finset (Fin n)\n⊢ #s ≤ n",
"ppTerm": "?m.4",
"assigned": true,
"usedConstants": [
"Fintype.card_fin",
"congrArg",
"Eq.mp",
"Fintype.card",
"LE.le",
"instLENat",
"Fin.fintype",
"Finset.card_le_univ",
"Nat",
"Finset.card",... | [] | simpa only [Fintype.card_fin] using s.card_le_univ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.NodupEquivFin | {
"line": 151,
"column": 6
} | {
"line": 157,
"column": 26
} | {
"line": 158,
"column": 2
} | [
{
"pp": "case mp.cons_cons\nα : Type u_1\nl l' l₁✝ l₂✝ : List α\na✝¹ : α\na✝ : l₁✝ <+ l₂✝\nIH : ∃ f, ∀ (ix : ℕ), l₁✝[ix]? = l₂✝[f ix]?\n⊢ ∃ f, ∀ (ix : ℕ), (a✝¹ :: l₁✝)[ix]? = (a✝¹ :: l₂✝)[f ix]?",
"ppTerm": "?mp.cons_cons",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"N... | [] | obtain ⟨f, hf⟩ := IH
refine
⟨OrderEmbedding.ofMapLEIff (fun ix : ℕ => if ix = 0 then 0 else (f ix.pred).succ) ?_, ?_⟩
· rintro ⟨_ | a⟩ ⟨_ | b⟩ <;> simp [Nat.succ_le_succ_iff]
· rintro ⟨_ | i⟩
· simp
· simpa using hf _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.NodupEquivFin | {
"line": 151,
"column": 6
} | {
"line": 157,
"column": 26
} | {
"line": 158,
"column": 2
} | [
{
"pp": "case mp.cons_cons\nα : Type u_1\nl l' l₁✝ l₂✝ : List α\na✝¹ : α\na✝ : l₁✝ <+ l₂✝\nIH : ∃ f, ∀ (ix : ℕ), l₁✝[ix]? = l₂✝[f ix]?\n⊢ ∃ f, ∀ (ix : ℕ), (a✝¹ :: l₁✝)[ix]? = (a✝¹ :: l₂✝)[f ix]?",
"ppTerm": "?mp.cons_cons",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"N... | [] | obtain ⟨f, hf⟩ := IH
refine
⟨OrderEmbedding.ofMapLEIff (fun ix : ℕ => if ix = 0 then 0 else (f ix.pred).succ) ?_, ?_⟩
· rintro ⟨_ | a⟩ ⟨_ | b⟩ <;> simp [Nat.succ_le_succ_iff]
· rintro ⟨_ | i⟩
· simp
· simpa using hf _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Sort | {
"line": 346,
"column": 8
} | {
"line": 346,
"column": 30
} | {
"line": 346,
"column": 30
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ninst✝² : DecidableRel r\ninst✝¹ : Std.Total r\ninst✝ : IsTrans α r\nl : List α\n⊢ ∀ (a b : α), (decide (r a b) || decide (r b a)) = true",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"total_of",
... | [] | simpa using total_of r | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Data.List.Sort | {
"line": 346,
"column": 8
} | {
"line": 346,
"column": 30
} | {
"line": 346,
"column": 30
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ninst✝² : DecidableRel r\ninst✝¹ : Std.Total r\ninst✝ : IsTrans α r\nl : List α\n⊢ ∀ (a b : α), (decide (r a b) || decide (r b a)) = true",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"total_of",
... | [] | simpa using total_of r | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sort | {
"line": 346,
"column": 8
} | {
"line": 346,
"column": 30
} | {
"line": 346,
"column": 30
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ninst✝² : DecidableRel r\ninst✝¹ : Std.Total r\ninst✝ : IsTrans α r\nl : List α\n⊢ ∀ (a b : α), (decide (r a b) || decide (r b a)) = true",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"total_of",
... | [] | simpa using total_of r | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1206,
"column": 4
} | {
"line": 1206,
"column": 28
} | {
"line": 1208,
"column": 0
} | [
{
"pp": "case right\nm n : ℕ\np : Fin (m + n) → Prop\ninst✝ : DecidablePred p\nhᵢ : ∃ i, p i\nhm : m ≤ ↑(Fin.find p hᵢ)\nhⱼ : ∃ j, p (natAdd m j)\ni : Fin n\nhi : i < Fin.find (fun j ↦ p (natAdd m j)) ⋯\n⊢ ¬p (natAdd m i)",
"ppTerm": "?right",
"assigned": true,
"usedConstants": [
"Fin.natAdd",... | [] | exact Fin.find_min hⱼ hi | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.List.Pairwise | {
"line": 96,
"column": 2
} | {
"line": 96,
"column": 89
} | {
"line": 97,
"column": 2
} | [
{
"pp": "α : Type u_1\nR : α → α → Prop\nl : List α\na : α\nh₁ : Pairwise R l\nha : a ∈ l\nhlast : R (l.getLast ⋯) (l.getLast ⋯)\n⊢ R a (l.getLast ⋯)",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"List.getLast",
"congrArg",
"List.dropLast_concat_getLast",
"Members... | [
"α : Type u_1\nR : α → α → Prop\nl : List α\na : α\nh₁ : Pairwise R l\nha✝ : a ∈ l\nha : a ∈ l.dropLast ∨ a = l.getLast ⋯\nhlast : R (l.getLast ⋯) (l.getLast ⋯)\n⊢ R a (l.getLast ⋯)"
] | rw [← dropLast_concat_getLast (ne_nil_of_mem ha), mem_append, List.mem_singleton] at ha | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 92,
"column": 6
} | {
"line": 98,
"column": 28
} | {
"line": 99,
"column": 4
} | [
{
"pp": "case cons.e_a\nα : Type u_2\ninst✝ : DecidableEq α\np : α → Bool\na : α\nas : List α\nh : (map (fun x ↦ count x as) (filter p as.dedup)).sum = countP p as\n⊢ (map (fun i ↦ count i as) (filter p (a :: as).dedup)).sum = countP p as",
"ppTerm": "?cons.e_a✝",
"assigned": true,
"usedConstants": ... | [] | refine _root_.trans ?_ h
by_cases ha : a ∈ as
· simp [dedup_cons_of_mem ha]
· simp only [dedup_cons_of_notMem ha, List.filter]
match p a with
| true => simp only [List.map_cons, List.sum_cons, List.count_eq_zero.2 ha, zero_add]
| false => simp only | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 92,
"column": 6
} | {
"line": 98,
"column": 28
} | {
"line": 99,
"column": 4
} | [
{
"pp": "case cons.e_a\nα : Type u_2\ninst✝ : DecidableEq α\np : α → Bool\na : α\nas : List α\nh : (map (fun x ↦ count x as) (filter p as.dedup)).sum = countP p as\n⊢ (map (fun i ↦ count i as) (filter p (a :: as).dedup)).sum = countP p as",
"ppTerm": "?cons.e_a✝",
"assigned": true,
"usedConstants": ... | [] | refine _root_.trans ?_ h
by_cases ha : a ∈ as
· simp [dedup_cons_of_mem ha]
· simp only [dedup_cons_of_notMem ha, List.filter]
match p a with
| true => simp only [List.map_cons, List.sum_cons, List.count_eq_zero.2 ha, zero_add]
| false => simp only | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 149,
"column": 79
} | {
"line": 149,
"column": 85
} | {
"line": 149,
"column": 85
} | [
{
"pp": "l : List ℤ\nh : l.prod = -1\n⊢ -1 ≠ 1",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"MulOne.toOne",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"Int.instNegInt",
"Ne",
"Int",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 149,
"column": 79
} | {
"line": 149,
"column": 85
} | {
"line": 149,
"column": 85
} | [
{
"pp": "l : List ℤ\nh : l.prod = -1\n⊢ -1 ≠ 1",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"MulOne.toOne",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"Int.instNegInt",
"Ne",
"Int",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 149,
"column": 79
} | {
"line": 149,
"column": 85
} | {
"line": 149,
"column": 85
} | [
{
"pp": "l : List ℤ\nh : l.prod = -1\n⊢ -1 ≠ 1",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"MulOne.toOne",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"Int.instNegInt",
"Ne",
"Int",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 152,
"column": 29
} | {
"line": 152,
"column": 35
} | {
"line": 152,
"column": 35
} | [
{
"pp": "l : List ℤ\nh : l.prod = -1\nx : ℤ\nh₁ : x ∈ l\nh₂ : x ≠ 1\n⊢ -1 * -1 = 1",
"ppTerm": "?m.72",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"MulOne.toMul"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 152,
"column": 29
} | {
"line": 152,
"column": 35
} | {
"line": 152,
"column": 35
} | [
{
"pp": "l : List ℤ\nh : l.prod = -1\nx : ℤ\nh₁ : x ∈ l\nh₂ : x ≠ 1\n⊢ -1 * -1 = 1",
"ppTerm": "?m.72",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"MulOne.toMul"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 152,
"column": 29
} | {
"line": 152,
"column": 35
} | {
"line": 152,
"column": 35
} | [
{
"pp": "l : List ℤ\nh : l.prod = -1\nx : ℤ\nh₁ : x ∈ l\nh₂ : x ≠ 1\n⊢ -1 * -1 = 1",
"ppTerm": "?m.72",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"MulOne.toMul"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 152,
"column": 40
} | {
"line": 152,
"column": 46
} | {
"line": 152,
"column": 46
} | [
{
"pp": "l : List ℤ\nh : l.prod = -1\nx : ℤ\nh₁ : x ∈ l\nh₂ : x ≠ 1\n⊢ -1 * -1 = 1",
"ppTerm": "?m.73",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"MulOne.toMul"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 152,
"column": 40
} | {
"line": 152,
"column": 46
} | {
"line": 152,
"column": 46
} | [
{
"pp": "l : List ℤ\nh : l.prod = -1\nx : ℤ\nh₁ : x ∈ l\nh₂ : x ≠ 1\n⊢ -1 * -1 = 1",
"ppTerm": "?m.73",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"MulOne.toMul"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.List.Lemmas | {
"line": 152,
"column": 40
} | {
"line": 152,
"column": 46
} | {
"line": 152,
"column": 46
} | [
{
"pp": "l : List ℤ\nh : l.prod = -1\nx : ℤ\nh₁ : x ∈ l\nh₂ : x ≠ 1\n⊢ -1 * -1 = 1",
"ppTerm": "?m.73",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"MulOne.toMul"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Bind | {
"line": 147,
"column": 27
} | {
"line": 147,
"column": 54
} | {
"line": 147,
"column": 54
} | [
{
"pp": "α : Type u_1\nβ : Type v\ns : Multiset α\nf : α → β\n⊢ (bind 0 fun x ↦ {f x}) = map f 0",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Multiset.map",
"congrArg",
"Multiset.map_zero",
"Multiset",
"id",
"Multiset.instSingleton",
... | [] | by rw [zero_bind, map_zero] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.OffDiag | {
"line": 59,
"column": 41
} | {
"line": 63,
"column": 29
} | {
"line": 65,
"column": 0
} | [
{
"pp": "α : Type u_1\nl : List α\nx : α × α\n⊢ x ∈ l.offDiag ↔ ∃ i x_1 j x_2, i ≠ j ∧ l[i] = x.fst ∧ l[j] = x.snd",
"ppTerm": "?m.46",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"_private.Mathlib.Data.List.OffDiag.0.List.mem_offDiag_iff_getElem._simp_1_5",
"List.eraseIdx",
... | [] | by
rcases x with ⟨x, y⟩
simp only [offDiag, exists_mem_zipIdx, mem_eraseIdx_iff_getElem, mem_flatMap, mem_map,
Nat.zero_add, Prod.ext_iff, ← exists_and_right, exists_and_left, @exists_comm α, and_assoc,
exists_eq_left', ne_comm] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Logic.Function.DependsOn | {
"line": 74,
"column": 36
} | {
"line": 74,
"column": 54
} | {
"line": 74,
"column": 54
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\nβ : Type u_3\ninst✝ : Nonempty β\nf : ((i : ι) → α i) → β\ns : Set ι\n⊢ FactorsThrough f s.restrict ↔ ∃ g, f = g ∘ s.restrict",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Function.comp",
"Membership.... | [
"ι : Type u_1\nα : ι → Type u_2\nβ : Type u_3\ninst✝ : Nonempty β\nf : ((i : ι) → α i) → β\ns : Set ι\n⊢ (∃ e, f = e ∘ s.restrict) ↔ ∃ g, f = g ∘ s.restrict"
] | factorsThrough_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fintype.Pi | {
"line": 234,
"column": 2
} | {
"line": 234,
"column": 29
} | {
"line": 235,
"column": 2
} | [
{
"pp": "α : Type u_1\nn : ℕ\nf : Fin (n + 1) → Set α\n⊢ ⋃ i, f i = f 0 ∪ iUnion (f ∘ Fin.succ)",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"instNeZeroNatHAdd_1",
"Fin.succ",
"Fin.cons",
"Function.comp",
"Set.instUnion",
"Fin.instOfNat",
"instO... | [
"case cons\nα : Type u_1\nn : ℕ\nx₀✝ : Set α\nx✝ : Fin n → Set α\n⊢ ⋃ i, Fin.cons x₀✝ x✝ i = Fin.cons x₀✝ x✝ 0 ∪ iUnion (Fin.cons x₀✝ x✝ ∘ Fin.succ)"
] | cases f using Fin.consCases | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Algebra.Group.Conj | {
"line": 290,
"column": 45
} | {
"line": 290,
"column": 65
} | {
"line": 290,
"column": 66
} | [
{
"pp": "α : Type u\ninst✝ : Monoid α\na b : α\n⊢ a ∈ Quotient.lift conjugatesOf ⋯ (ConjClasses.mk b) ↔ IsConj b a",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"IsConj.setoid",
"congrArg",
"ConjClasses.mk",
"Membership.mem",
"conjugatesOf",
... | [
"α : Type u\ninst✝ : Monoid α\na b : α\n⊢ a ∈ Quotient.lift conjugatesOf ⋯ ⟦b⟧ ↔ IsConj b a"
] | ← quotient_mk_eq_mk, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Submonoid.Defs | {
"line": 320,
"column": 21
} | {
"line": 320,
"column": 38
} | {
"line": 320,
"column": 39
} | [
{
"pp": "M : Type u_1\nN : Type u_2\ninst✝¹ : MulOneClass M\ns : Set M\ninst✝ : MulOneClass N\nf g : M →* N\n⊢ 1 ∈ {x | f x = g x}",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"MonoidHom.instFunLike",
"MonoidHom",
"congrArg",
... | [
"M : Type u_1\nN : Type u_2\ninst✝¹ : MulOneClass M\ns : Set M\ninst✝ : MulOneClass N\nf g : M →* N\n⊢ f 1 = g 1"
] | Set.mem_setOf_eq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Submonoid.Defs | {
"line": 320,
"column": 39
} | {
"line": 320,
"column": 49
} | {
"line": 320,
"column": 50
} | [
{
"pp": "M : Type u_1\nN : Type u_2\ninst✝¹ : MulOneClass M\ns : Set M\ninst✝ : MulOneClass N\nf g : M →* N\n⊢ f 1 = g 1",
"ppTerm": "?m.32",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"MonoidHom.instFunLike",
"MonoidHom",
"congrArg",
"id",
... | [
"M : Type u_1\nN : Type u_2\ninst✝¹ : MulOneClass M\ns : Set M\ninst✝ : MulOneClass N\nf g : M →* N\n⊢ 1 = g 1"
] | f.map_one, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Pointwise.Set.Basic | {
"line": 688,
"column": 13
} | {
"line": 688,
"column": 50
} | {
"line": 690,
"column": 0
} | [
{
"pp": "α : Type u_2\ninst✝ : Monoid α\na : α\nn : ℕ\n⊢ {a} ^ (n + 1) = {a ^ (n + 1)}",
"ppTerm": "?m.43",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"Set.image_singleton",
"Monoid.toMulOneClass",
"congrArg",
"pow_s... | [] | by simp [pow_succ, singleton_pow _ n] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Pointwise.Set.Basic | {
"line": 778,
"column": 4
} | {
"line": 785,
"column": 97
} | {
"line": 786,
"column": 2
} | [
{
"pp": "case refine_1\nα : Type u_2\ninst✝ : DivisionMonoid α\ns t : Set α\nh : s * t = 1\n⊢ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1",
"ppTerm": "?refine_1",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"DivInvMonoid.toInv",
"InvOneClass.toOne",
"HMul.hMul",
"eq_inv_of... | [] | have hst : (s * t).Nonempty := h.symm.subst one_nonempty
obtain ⟨a, ha⟩ := hst.of_image2_left
obtain ⟨b, hb⟩ := hst.of_image2_right
have H : ∀ {a b}, a ∈ s → b ∈ t → a * b = (1 : α) := fun {a b} ha hb =>
h.subset <| mem_image2_of_mem ha hb
refine ⟨a, b, ?_, ?_, H ha hb⟩ <;> refine eq_singleton_iff... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Pointwise.Set.Basic | {
"line": 778,
"column": 4
} | {
"line": 785,
"column": 97
} | {
"line": 786,
"column": 2
} | [
{
"pp": "case refine_1\nα : Type u_2\ninst✝ : DivisionMonoid α\ns t : Set α\nh : s * t = 1\n⊢ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1",
"ppTerm": "?refine_1",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"DivInvMonoid.toInv",
"InvOneClass.toOne",
"HMul.hMul",
"eq_inv_of... | [] | have hst : (s * t).Nonempty := h.symm.subst one_nonempty
obtain ⟨a, ha⟩ := hst.of_image2_left
obtain ⟨b, hb⟩ := hst.of_image2_right
have H : ∀ {a b}, a ∈ s → b ∈ t → a * b = (1 : α) := fun {a b} ha hb =>
h.subset <| mem_image2_of_mem ha hb
refine ⟨a, b, ?_, ?_, H ha hb⟩ <;> refine eq_singleton_iff... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Pointwise.Set.Basic | {
"line": 829,
"column": 2
} | {
"line": 829,
"column": 21
} | {
"line": 829,
"column": 21
} | [
{
"pp": "α : Type u_2\ninst✝ : DivisionMonoid α\ns t : Set α\nht : 1 ∈ t\n⊢ s ⊆ s / t",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"id",
"MulOne.t... | [
"α : Type u_2\ninst✝ : DivisionMonoid α\ns t : Set α\nht : 1 ∈ t\n⊢ s ⊆ s * t⁻¹"
] | rw [div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Pointwise.Set.Basic | {
"line": 832,
"column": 2
} | {
"line": 832,
"column": 21
} | {
"line": 832,
"column": 21
} | [
{
"pp": "α : Type u_2\ninst✝ : DivisionMonoid α\ns t : Set α\nhs : 1 ∈ s\n⊢ t⁻¹ ⊆ s / t",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
... | [
"α : Type u_2\ninst✝ : DivisionMonoid α\ns t : Set α\nhs : 1 ∈ s\n⊢ t⁻¹ ⊆ s * t⁻¹"
] | rw [div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Subgroup.Defs | {
"line": 132,
"column": 2
} | {
"line": 132,
"column": 21
} | {
"line": 132,
"column": 21
} | [
{
"pp": "M : Type u_3\nS : Type u_4\ninst✝¹ : DivInvMonoid M\ninst✝ : SetLike S M\nhSM : SubgroupClass S M\nH : S\nx y : M\nhx : x ∈ H\nhy : y ∈ H\n⊢ x / y ∈ H",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
... | [
"M : Type u_3\nS : Type u_4\ninst✝¹ : DivInvMonoid M\ninst✝ : SetLike S M\nhSM : SubgroupClass S M\nH : S\nx y : M\nhx : x ∈ H\nhy : y ∈ H\n⊢ x * y⁻¹ ∈ H"
] | rw [div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Subgroup.Ker | {
"line": 436,
"column": 63
} | {
"line": 436,
"column": 71
} | {
"line": 436,
"column": 72
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Group G\nN : Type u_5\ninst✝ : Group N\nf : G →* N\nH : Subgroup N\n⊢ ↑H ∩ Set.range ⇑f = ↑(f.range ⊓ H)",
"ppTerm": "?m.44",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MonoidHom.range",
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.... | [
"G : Type u_1\ninst✝¹ : Group G\nN : Type u_5\ninst✝ : Group N\nf : G →* N\nH : Subgroup N\n⊢ ↑H ∩ Set.range ⇑f = ↑f.range ∩ ↑H"
] | coe_inf, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Subgroup.Ker | {
"line": 565,
"column": 35
} | {
"line": 565,
"column": 53
} | {
"line": 565,
"column": 54
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Group G\nN : Type u_5\ninst✝ : Group N\nf : G →* N\nH K : Subgroup G\nhH : f.ker ≤ H\nhK : f.ker ≤ K\nhf : H ⊔ f.ker = K ⊔ f.ker\n⊢ H = K",
"ppTerm": "?m.113",
"assigned": true,
"usedConstants": [
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
... | [
"G : Type u_1\ninst✝¹ : Group G\nN : Type u_5\ninst✝ : Group N\nf : G →* N\nH K : Subgroup G\nhH : f.ker ≤ H\nhK : f.ker ≤ K\nhf : H = K ⊔ f.ker\n⊢ H = K"
] | sup_of_le_left hH, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Subgroup.ZPowers.Basic | {
"line": 106,
"column": 2
} | {
"line": 106,
"column": 6
} | {
"line": 107,
"column": 2
} | [
{
"pp": "A : Type u_2\ninst✝ : AddGroup A\nx : A\n⊢ ⇑Multiplicative.ofAdd '' ↑(AddSubgroup.zmultiples x) = ↑(Subgroup.zpowers (Multiplicative.ofAdd x))",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Multiplicative.group",
"Equiv.instEquivLike",
"Equiv",
"Subgroup"... | [
"A : Type u_2\ninst✝ : AddGroup A\nx : A\n⊢ ↑(Subgroup.zpowers (Multiplicative.ofAdd x)) = ⇑Multiplicative.ofAdd '' ↑(AddSubgroup.zmultiples x)"
] | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Logic.Encodable.Basic | {
"line": 196,
"column": 22
} | {
"line": 196,
"column": 39
} | {
"line": 196,
"column": 40
} | [
{
"pp": "α : Type u_1\ninst✝ : Encodable α\nn : ℕ\n⊢ decode₂ α n ≠ none ↔ n ∈ {x | ∃ y, encode y = x}",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"setOf",
"Encodable.decode₂",
"Membership.mem",
"Exists",
"id",
"Ne",
"Option.none",
"Iff",
... | [
"α : Type u_1\ninst✝ : Encodable α\nn : ℕ\n⊢ decode₂ α n ≠ none ↔ ∃ y, encode y = n"
] | Set.mem_setOf_eq, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Logic.Encodable.Basic | {
"line": 292,
"column": 18
} | {
"line": 292,
"column": 24
} | {
"line": 292,
"column": 24
} | [
{
"pp": "n : ℕ\nh : 2 ≤ n\n⊢ 0 < 2",
"ppTerm": "?m.51",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",
"Bool",
"Nat.decLt",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
"De... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Logic.Encodable.Basic | {
"line": 292,
"column": 18
} | {
"line": 292,
"column": 24
} | {
"line": 292,
"column": 24
} | [
{
"pp": "n : ℕ\nh : 2 ≤ n\n⊢ 0 < 2",
"ppTerm": "?m.51",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",
"Bool",
"Nat.decLt",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
"De... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Logic.Encodable.Basic | {
"line": 292,
"column": 18
} | {
"line": 292,
"column": 24
} | {
"line": 292,
"column": 24
} | [
{
"pp": "n : ℕ\nh : 2 ≤ n\n⊢ 0 < 2",
"ppTerm": "?m.51",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",
"Bool",
"Nat.decLt",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
"De... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Idempotent | {
"line": 57,
"column": 91
} | {
"line": 57,
"column": 96
} | {
"line": 57,
"column": 96
} | [
{
"pp": "S : Type u_3\ninst✝ : Semigroup S\na b : S\nhab : Commute a b\nha : IsIdempotentElem a\nhb : IsIdempotentElem b\n⊢ a * (b * b) = a * b",
"ppTerm": "?m.32",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"HMul.hMul",
"congrArg",
"id",
"I... | [
"S : Type u_3\ninst✝ : Semigroup S\na b : S\nhab : Commute a b\nha : IsIdempotentElem a\nhb : IsIdempotentElem b\n⊢ a * b = a * b"
] | hb.eq | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Subgroup.Basic | {
"line": 1049,
"column": 2
} | {
"line": 1050,
"column": 58
} | {
"line": 1051,
"column": 2
} | [
{
"pp": "case left\nG : Type u_1\ninst✝ : Group G\nH₁ H₂ : Subgroup G\nhH₁ : H₁.Normal\nhH₂ : H₂.Normal\nhdis : Disjoint H₁ H₂\nx y : G\nhx : x ∈ H₁\nhy : y ∈ H₂\n⊢ x * y * x⁻¹ * y⁻¹ ∈ ↑H₁.toSubmonoid",
"ppTerm": "?left",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"SetLike.mem_coe._s... | [
"case right\nG : Type u_1\ninst✝ : Group G\nH₁ H₂ : Subgroup G\nhH₁ : H₁.Normal\nhH₂ : H₂.Normal\nhdis : Disjoint H₁ H₂\nx y : G\nhx : x ∈ H₁\nhy : y ∈ H₂\n⊢ x * y * x⁻¹ * y⁻¹ ∈ ↑H₂.toSubmonoid"
] | · suffices x * (y * x⁻¹ * y⁻¹) ∈ H₁ by simpa [mul_assoc]
exact H₁.mul_mem hx (hH₁.conj_mem _ (H₁.inv_mem hx) _) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Group.Subgroup.Basic | {
"line": 1095,
"column": 6
} | {
"line": 1095,
"column": 17
} | {
"line": 1095,
"column": 18
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nN : Subgroup G\nhn : N.Normal\ng : G\nhg : g ∈ N\nht : normalClosure {⟨g, hg⟩} = ⊤\nc : G\nhg' : c * g * c⁻¹ ∈ N\nhc : IsConj g (c * g * c⁻¹)\nh : ∀ (x : ↥N), (MulAut.conj c) ↑x ∈ N\nhs : Surjective ⇑(((MulEquiv.toMonoidHom (MulAut.conj c)).restrict N).codRestrict N h)\n⊢... | [
"G : Type u_1\ninst✝ : Group G\nN : Subgroup G\nhn : N.Normal\ng : G\nhg : g ∈ N\nht : normalClosure {⟨g, hg⟩} = ⊤\nc : G\nhg' : c * g * c⁻¹ ∈ N\nhc : IsConj g (c * g * c⁻¹)\nh : ∀ (x : ↥N), (MulAut.conj c) ↑x ∈ N\nhs : Surjective ⇑(((MulEquiv.toMonoidHom (MulAut.conj c)).restrict N).codRestrict N h)\n⊢ ⊤ ≤ normalC... | eq_top_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.BigOperators.Group.List | {
"line": 164,
"column": 4
} | {
"line": 166,
"column": 26
} | {
"line": 168,
"column": 0
} | [
{
"pp": "case cons.inr\nM : Type u_3\ninst✝² : Monoid M\ninst✝¹ : Preorder M\ninst✝ : CanonicallyOrderedMul M\nx y : M\nys : List M\nih : x ∈ ys → x ≤ ys.prod\nh₁ : x ∈ ys\n⊢ x ≤ (y :: ys).prod",
"ppTerm": "?cons.inr",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Monoid.toMulOne... | [] | · specialize ih h₁
simp only [List.prod_cons]
exact le_mul_left ih | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Order.BigOperators.Group.List | {
"line": 220,
"column": 4
} | {
"line": 221,
"column": 49
} | {
"line": 223,
"column": 0
} | [
{
"pp": "case cons\nM : Type u_3\nN : Type u_4\ninst✝² : AddZeroClass M\ninst✝¹ : Zero N\ninst✝ : LinearOrder N\nf : M → N\nh0 : f 0 ≤ 0\nhadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)\nhd : M\ntl : List M\nIH : f tl.sum ≤ foldr max 0 (map f tl)\n⊢ f (hd :: tl).sum ≤ foldr max 0 (map f (hd :: tl))",
"ppTer... | [] | simp only [List.sum_cons, List.foldr_map, List.foldr] at IH ⊢
exact (hadd _ _).trans (max_le_max le_rfl IH) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.BigOperators.Group.List | {
"line": 220,
"column": 4
} | {
"line": 221,
"column": 49
} | {
"line": 223,
"column": 0
} | [
{
"pp": "case cons\nM : Type u_3\nN : Type u_4\ninst✝² : AddZeroClass M\ninst✝¹ : Zero N\ninst✝ : LinearOrder N\nf : M → N\nh0 : f 0 ≤ 0\nhadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)\nhd : M\ntl : List M\nIH : f tl.sum ≤ foldr max 0 (map f tl)\n⊢ f (hd :: tl).sum ≤ foldr max 0 (map f (hd :: tl))",
"ppTer... | [] | simp only [List.sum_cons, List.foldr_map, List.foldr] at IH ⊢
exact (hadd _ _).trans (max_le_max le_rfl IH) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Submonoid.Membership | {
"line": 90,
"column": 73
} | {
"line": 92,
"column": 60
} | {
"line": 94,
"column": 0
} | [
{
"pp": "M : Type u_1\ninst✝ : MulOneClass M\nS : Set (Submonoid M)\nSne : S.Nonempty\nhS : DirectedOn (fun x1 x2 ↦ x1 ≤ x2) S\nx : M\n⊢ x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"Iff.of_eq",
"congrArg",
"iSup",
"PartialOrder.toPreo... | [] | by
haveI : Nonempty S := Sne.to_subtype
simp [sSup_eq_iSup', mem_iSup_of_directed hS.directed_val] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.BigOperators.Group.List | {
"line": 266,
"column": 2
} | {
"line": 268,
"column": 53
} | {
"line": 270,
"column": 0
} | [
{
"pp": "α : Type u_5\nβ : Type u_6\ninst✝³ : Monoid α\ninst✝² : AddMonoid β\ninst✝¹ : Preorder β\ninst✝ : AddLeftMono β\nl : List α\nf : α → β\nh_one : f 1 ≤ 0\nh_mul : ∀ (a b : α), f (a * b) ≤ f a + f b\n⊢ f l.prod ≤ (map f l).sum",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Eq... | [] | induction l with
| nil => simp [h_one]
| cons hd tl IH => grw [prod_cons, h_mul, IH]; simp | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Algebra.Order.BigOperators.Group.List | {
"line": 266,
"column": 2
} | {
"line": 268,
"column": 53
} | {
"line": 270,
"column": 0
} | [
{
"pp": "α : Type u_5\nβ : Type u_6\ninst✝³ : Monoid α\ninst✝² : AddMonoid β\ninst✝¹ : Preorder β\ninst✝ : AddLeftMono β\nl : List α\nf : α → β\nh_one : f 1 ≤ 0\nh_mul : ∀ (a b : α), f (a * b) ≤ f a + f b\n⊢ f l.prod ≤ (map f l).sum",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Eq... | [] | induction l with
| nil => simp [h_one]
| cons hd tl IH => grw [prod_cons, h_mul, IH]; simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.BigOperators.Group.List | {
"line": 266,
"column": 2
} | {
"line": 268,
"column": 53
} | {
"line": 270,
"column": 0
} | [
{
"pp": "α : Type u_5\nβ : Type u_6\ninst✝³ : Monoid α\ninst✝² : AddMonoid β\ninst✝¹ : Preorder β\ninst✝ : AddLeftMono β\nl : List α\nf : α → β\nh_one : f 1 ≤ 0\nh_mul : ∀ (a b : α), f (a * b) ≤ f a + f b\n⊢ f l.prod ≤ (map f l).sum",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Eq... | [] | induction l with
| nil => simp [h_one]
| cons hd tl IH => grw [prod_cons, h_mul, IH]; simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Sum | {
"line": 49,
"column": 2
} | {
"line": 49,
"column": 37
} | {
"line": 51,
"column": 0
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ns : Multiset α\nt : Multiset β\nx : α ⊕ β\n⊢ x ∈ s.disjSum t ↔ (∃ a, a ∈ s ∧ inl a = x) ∨ ∃ b, b ∈ t ∧ inr b = x",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Multiset.map",
"congrArg",
"_private.Mathlib.Data.Multise... | [] | simp_rw [disjSum, mem_add, mem_map] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Data.Multiset.Sum | {
"line": 49,
"column": 2
} | {
"line": 49,
"column": 37
} | {
"line": 51,
"column": 0
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ns : Multiset α\nt : Multiset β\nx : α ⊕ β\n⊢ x ∈ s.disjSum t ↔ (∃ a, a ∈ s ∧ inl a = x) ∨ ∃ b, b ∈ t ∧ inr b = x",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Multiset.map",
"congrArg",
"_private.Mathlib.Data.Multise... | [] | simp_rw [disjSum, mem_add, mem_map] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Multiset.Sum | {
"line": 49,
"column": 2
} | {
"line": 49,
"column": 37
} | {
"line": 51,
"column": 0
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ns : Multiset α\nt : Multiset β\nx : α ⊕ β\n⊢ x ∈ s.disjSum t ↔ (∃ a, a ∈ s ∧ inl a = x) ∨ ∃ b, b ∈ t ∧ inr b = x",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Multiset.map",
"congrArg",
"_private.Mathlib.Data.Multise... | [] | simp_rw [disjSum, mem_add, mem_map] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Submonoid.Membership | {
"line": 562,
"column": 2
} | {
"line": 562,
"column": 6
} | {
"line": 563,
"column": 2
} | [
{
"pp": "A : Type u_2\ninst✝ : AddMonoid A\nx : A\n⊢ ⇑Multiplicative.ofAdd '' ↑(AddSubmonoid.multiples x) = ↑(Submonoid.powers (Multiplicative.ofAdd x))",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Multiplicative.monoid",
"Equiv.instEquivLike",
"Monoid.toMulOneClass",... | [
"A : Type u_2\ninst✝ : AddMonoid A\nx : A\n⊢ ↑(Submonoid.powers (Multiplicative.ofAdd x)) = ⇑Multiplicative.ofAdd '' ↑(AddSubmonoid.multiples x)"
] | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Algebra.Group.Submonoid.Membership | {
"line": 564,
"column": 2
} | {
"line": 564,
"column": 45
} | {
"line": 566,
"column": 0
} | [
{
"pp": "A : Type u_2\ninst✝ : AddMonoid A\nx : A\n⊢ ⇑Multiplicative.ofAdd.symm '' ↑(Submonoid.powers (Multiplicative.ofAdd x)) = ↑(AddSubmonoid.multiples x)",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Multiplicative.monoid",
"Equiv.instEquivLike",
"Equiv",
"of... | [] | exact ofMul_image_powers_eq_multiples_ofMul | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.List.MinMax | {
"line": 178,
"column": 4
} | {
"line": 179,
"column": 14
} | {
"line": 180,
"column": 4
} | [
{
"pp": "case none\nα : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder β\nf : α → β\ninst✝ : DecidableEq α\nhd : α\ntl : List α\nm a : α\nha : a ∈ hd :: tl\nham : f m ≤ f a\nhm : Option.rec (some hd) (fun val ↦ if f hd < f val then some val else some hd) (argmax f tl) = some m\nh : argmax f tl = none\n⊢ (bif hd =... | [
"case some\nα : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder β\nf : α → β\ninst✝ : DecidableEq α\nhd : α\ntl : List α\nm a : α\nha : a ∈ hd :: tl\nham : f m ≤ f a\nhm : Option.rec (some hd) (fun val ↦ if f hd < f val then some val else some hd) (argmax f tl) = some m\nval✝ : α\nh : argmax f tl = some val✝\n⊢ (bif h... | · rw [h] at hm
simp_all | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.List.MinMax | {
"line": 407,
"column": 2
} | {
"line": 407,
"column": 39
} | {
"line": 409,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : LinearOrder α\nl : List α\nh : 0 < l.length\n⊢ l.maximum = ↑(maximum_of_length_pos h)",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"List.maximum",
"WithBot.some",
"WithBot",
"List.coe_maximum_of_length_pos",
"congrArg",
... | [] | simp only [coe_maximum_of_length_pos] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Order.Hom.BoundedLattice | {
"line": 340,
"column": 32
} | {
"line": 340,
"column": 62
} | {
"line": 340,
"column": 62
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\nδ : Type u_5\ninst✝⁴ : FunLike F α β\ninst✝³ : Max α\ninst✝² : Bot α\ninst✝¹ : SemilatticeSup β\ninst✝ : OrderBot β\nP : β → Prop\nPbot : P ⊥\nPsup : ∀ ⦃x y : β⦄, P x → P y → P (x ⊔ y)\nthis✝ : OrderBot { x // P x } := Subtype.orderBot Pbot\nthis ... | [] | by simp [Subtype.coe_bot Pbot] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Hom.BoundedLattice | {
"line": 483,
"column": 64
} | {
"line": 483,
"column": 94
} | {
"line": 483,
"column": 94
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\nδ : Type u_5\ninst✝⁸ : FunLike F α β\ninst✝⁷ : Lattice α\ninst✝⁶ : Lattice β\ninst✝⁵ : Lattice γ\ninst✝⁴ : Lattice δ\ninst✝³ : BoundedOrder α\ninst✝² : BoundedOrder β\ninst✝¹ : BoundedOrder γ\ninst✝ : BoundedOrder δ\nP : β → Prop\nPbot : P ⊥\nPtop... | [] | by simp [Subtype.coe_bot Pbot] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Choose.Basic | {
"line": 118,
"column": 51
} | {
"line": 118,
"column": 57
} | {
"line": 119,
"column": 2
} | [
{
"pp": "x✝ : ℕ\nhk : x✝ ≤ 0\n⊢ 0 < choose 0 0",
"ppTerm": "?m.88",
"assigned": true,
"usedConstants": [
"Nat.choose",
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",
"Bool",
"Nat.decLt",
"Eq.refl",
"instLTNat"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Nat.Choose.Basic | {
"line": 132,
"column": 15
} | {
"line": 132,
"column": 21
} | {
"line": 133,
"column": 2
} | [
{
"pp": "⊢ (0 + 1) * choose 0 0 = (0 + 1).choose (0 + 1) * (0 + 1)",
"ppTerm": "?m.42",
"assigned": true,
"usedConstants": [
"Nat.choose",
"HMul.hMul",
"of_decide_eq_true",
"id",
"instMulNat",
"instOfNatNat",
"Bool.true",
"instHAdd",
"HAdd.hAdd",... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Nat.Choose.Basic | {
"line": 132,
"column": 15
} | {
"line": 132,
"column": 21
} | {
"line": 133,
"column": 2
} | [
{
"pp": "⊢ (0 + 1) * choose 0 0 = (0 + 1).choose (0 + 1) * (0 + 1)",
"ppTerm": "?m.42",
"assigned": true,
"usedConstants": [
"Nat.choose",
"HMul.hMul",
"of_decide_eq_true",
"id",
"instMulNat",
"instOfNatNat",
"Bool.true",
"instHAdd",
"HAdd.hAdd",... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Choose.Basic | {
"line": 132,
"column": 15
} | {
"line": 132,
"column": 21
} | {
"line": 133,
"column": 2
} | [
{
"pp": "⊢ (0 + 1) * choose 0 0 = (0 + 1).choose (0 + 1) * (0 + 1)",
"ppTerm": "?m.42",
"assigned": true,
"usedConstants": [
"Nat.choose",
"HMul.hMul",
"of_decide_eq_true",
"id",
"instMulNat",
"instOfNatNat",
"Bool.true",
"instHAdd",
"HAdd.hAdd",... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Sublists | {
"line": 76,
"column": 2
} | {
"line": 80,
"column": 21
} | {
"line": 81,
"column": 2
} | [
{
"pp": "α : Type u\ns t : List α\n⊢ s ∈ t.sublists' ↔ s <+ t",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"List.sublists'",
"Eq.mpr",
"congrArg",
"List.eq_nil_of_sublist_nil",
"Membership.mem",
"id",
"List.rec",
"List",
"Iff",
... | [
"case cons\nα : Type u\na : α\nt : List α\nIH : ∀ {s : List α}, s ∈ t.sublists' ↔ s <+ t\ns : List α\n⊢ s ∈ (a :: t).sublists' ↔ s <+ a :: t"
] | induction t generalizing s with
| nil =>
simp only [sublists'_nil, mem_singleton]
exact ⟨fun h => by rw [h], eq_nil_of_sublist_nil⟩
| cons a t IH => ?_ | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Finset.Max | {
"line": 546,
"column": 42
} | {
"line": 546,
"column": 57
} | {
"line": 546,
"column": 57
} | [
{
"pp": "α : Type u_2\ninst✝ : LinearOrder α\ni : α\ns : Finset α\nhs : s.Nonempty\nhis : (∀ x ∈ ↑s, i ≤ x) ∧ i ∈ upperBounds (lowerBounds ↑s)\n⊢ i = s.min' hs",
"ppTerm": "?m.48",
"assigned": true,
"usedConstants": [
"lowerBounds",
"congrArg",
"Finset",
"PartialOrder.toPreor... | [
"α : Type u_2\ninst✝ : LinearOrder α\ni : α\ns : Finset α\nhs : s.Nonempty\nhis : (∀ x ∈ ↑s, i ≤ x) ∧ ∀ x ∈ lowerBounds ↑s, x ≤ i\n⊢ i = s.min' hs"
] | mem_upperBounds | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Choose.Basic | {
"line": 240,
"column": 2
} | {
"line": 251,
"column": 84
} | {
"line": 253,
"column": 0
} | [
{
"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)!) =\n (m + 1) * (m * (p + 1) + p).choose p * ((m * (p + 1))! * (p + 1)!)",
"ppTerm": "?m.82",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Trans.trans"... | [] | calc
(m * (p + 1) + (p + 1)).choose (p + 1) * ((m * (p + 1))! * (p + 1)!)
= (m * (p + 1) + (p + 1)).choose (p + 1) * (m * (p + 1))! * (p + 1)! := by lia
_ = (m * (p + 1) + (p + 1))! := by rw [add_choose_mul_factorial_mul_factorial]
_ = ((m * (p + 1) + p) + 1)! := by lia
_ = ((m * (p + 1) + p) + 1)... | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcTactic |
Mathlib.Data.List.Sublists | {
"line": 160,
"column": 2
} | {
"line": 160,
"column": 89
} | {
"line": 162,
"column": 0
} | [
{
"pp": "α : Type u\nl : List α\n⊢ l.reverse.sublists' = map reverse l.sublists",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"List.sublists'",
"congrArg",
"List.map",
"Function.comp",
"List.sublists",
"List.map_map",
"List.sublists_eq_sublists'",... | [] | simp only [sublists_eq_sublists', map_map, map_id'' reverse_reverse, Function.comp_def] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Sublists | {
"line": 160,
"column": 2
} | {
"line": 160,
"column": 89
} | {
"line": 162,
"column": 0
} | [
{
"pp": "α : Type u\nl : List α\n⊢ l.reverse.sublists' = map reverse l.sublists",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"List.sublists'",
"congrArg",
"List.map",
"Function.comp",
"List.sublists",
"List.map_map",
"List.sublists_eq_sublists'",... | [] | simp only [sublists_eq_sublists', map_map, map_id'' reverse_reverse, Function.comp_def] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sublists | {
"line": 160,
"column": 2
} | {
"line": 160,
"column": 89
} | {
"line": 162,
"column": 0
} | [
{
"pp": "α : Type u\nl : List α\n⊢ l.reverse.sublists' = map reverse l.sublists",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"List.sublists'",
"congrArg",
"List.map",
"Function.comp",
"List.sublists",
"List.map_map",
"List.sublists_eq_sublists'",... | [] | simp only [sublists_eq_sublists', map_map, map_id'' reverse_reverse, Function.comp_def] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Sublists | {
"line": 280,
"column": 4
} | {
"line": 281,
"column": 53
} | {
"line": 283,
"column": 0
} | [
{
"pp": "case cons_cons\nα : Type u\nl l' l₁✝ l₂✝ : List α\na : α\ns : l₁✝ <+ l₂✝\nIH : l₁✝ ∈ sublistsLen l₁✝.length l₂✝\n⊢ a :: l₁✝ ∈ sublistsLen (a :: l₁✝).length (a :: l₂✝)",
"ppTerm": "?cons_cons",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"congrArg",
"Lis... | [] | rw [length, sublistsLen_succ_cons]
exact mem_append_right _ (mem_map.2 ⟨_, IH, rfl⟩) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sublists | {
"line": 280,
"column": 4
} | {
"line": 281,
"column": 53
} | {
"line": 283,
"column": 0
} | [
{
"pp": "case cons_cons\nα : Type u\nl l' l₁✝ l₂✝ : List α\na : α\ns : l₁✝ <+ l₂✝\nIH : l₁✝ ∈ sublistsLen l₁✝.length l₂✝\n⊢ a :: l₁✝ ∈ sublistsLen (a :: l₁✝).length (a :: l₂✝)",
"ppTerm": "?cons_cons",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"congrArg",
"Lis... | [] | rw [length, sublistsLen_succ_cons]
exact mem_append_right _ (mem_map.2 ⟨_, IH, rfl⟩) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Powerset | {
"line": 37,
"column": 66
} | {
"line": 40,
"column": 17
} | {
"line": 42,
"column": 0
} | [
{
"pp": "α : Type u_1\ns t : Finset α\n⊢ s ∈ t.powerset ↔ s ⊆ t",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"Finset.powerset._proof_1",
"Finset.powerset._proof_2",
"Multiset.Nodup",
"Iff.of_eq",
"congrArg",
"Finset",
"PartialOrder.toPreorder",
... | [] | by
cases s
simp [powerset, mem_mk, mem_pmap, mk.injEq, exists_prop, exists_eq_right,
← val_le_iff] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Interval.Set.WithBotTop | {
"line": 63,
"column": 78
} | {
"line": 63,
"column": 100
} | {
"line": 65,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\na b : α\n⊢ some ⁻¹' Ioo ↑a ↑b = Ioo a b",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Set.Ioi",
"WithTop.instPreorder",
"congrArg",
"WithTop.preimage_coe_Iio",
"Set.instInter",
"WithTop.some",
"Inter.int... | [] | simp [← Ioi_inter_Iio] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Order.Interval.Set.WithBotTop | {
"line": 63,
"column": 78
} | {
"line": 63,
"column": 100
} | {
"line": 65,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\na b : α\n⊢ some ⁻¹' Ioo ↑a ↑b = Ioo a b",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Set.Ioi",
"WithTop.instPreorder",
"congrArg",
"WithTop.preimage_coe_Iio",
"Set.instInter",
"WithTop.some",
"Inter.int... | [] | simp [← Ioi_inter_Iio] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Interval.Set.WithBotTop | {
"line": 63,
"column": 78
} | {
"line": 63,
"column": 100
} | {
"line": 65,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\na b : α\n⊢ some ⁻¹' Ioo ↑a ↑b = Ioo a b",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Set.Ioi",
"WithTop.instPreorder",
"congrArg",
"WithTop.preimage_coe_Iio",
"Set.instInter",
"WithTop.some",
"Inter.int... | [] | simp [← Ioi_inter_Iio] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Interval.Set.WithBotTop | {
"line": 75,
"column": 2
} | {
"line": 75,
"column": 24
} | {
"line": 77,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\na : α\n⊢ some ⁻¹' Ioo ↑a ⊤ = Ioi a",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Set.Ioi",
"WithTop.preimage_coe_Iio_top",
"WithTop.instPreorder",
"congrArg",
"Set.univ",
"Set.inter_univ",
"Set.instInte... | [] | simp [← Ioi_inter_Iio] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Order.Interval.Set.WithBotTop | {
"line": 75,
"column": 2
} | {
"line": 75,
"column": 24
} | {
"line": 77,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\na : α\n⊢ some ⁻¹' Ioo ↑a ⊤ = Ioi a",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Set.Ioi",
"WithTop.preimage_coe_Iio_top",
"WithTop.instPreorder",
"congrArg",
"Set.univ",
"Set.inter_univ",
"Set.instInte... | [] | simp [← Ioi_inter_Iio] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Interval.Set.WithBotTop | {
"line": 75,
"column": 2
} | {
"line": 75,
"column": 24
} | {
"line": 77,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\na : α\n⊢ some ⁻¹' Ioo ↑a ⊤ = Ioi a",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Set.Ioi",
"WithTop.preimage_coe_Iio_top",
"WithTop.instPreorder",
"congrArg",
"Set.univ",
"Set.inter_univ",
"Set.instInte... | [] | simp [← Ioi_inter_Iio] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Cover | {
"line": 168,
"column": 35
} | {
"line": 168,
"column": 62
} | {
"line": 168,
"column": 63
} | [
{
"pp": "α : Type u_1\ninst✝ : PartialOrder α\na b : α\nh : a ⩿ b\n⊢ {a, b} \\ {b} ⊆ {a}",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Set.sdiff_singleton_subset_iff",
"Set.instSingletonSet",
"id",
"Insert.insert",
"LE.le",... | [
"α : Type u_1\ninst✝ : PartialOrder α\na b : α\nh : a ⩿ b\n⊢ {a, b} ⊆ {b, a}"
] | sdiff_singleton_subset_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Cover | {
"line": 481,
"column": 80
} | {
"line": 481,
"column": 86
} | {
"line": 482,
"column": 0
} | [
{
"pp": "⊢ ∀ {a b : Bool}, (a ≤ b ∧ ∀ ⦃c : Bool⦄, a < c → ¬c < b) ↔ a ≤ b",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Bool.instDecidableForallOfDecidablePred",
"Preorder.toLT",
"of_decide_eq_true",
"Bool.instPartialOrder",
"Partia... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Order.Cover | {
"line": 482,
"column": 78
} | {
"line": 482,
"column": 84
} | {
"line": 484,
"column": 0
} | [
{
"pp": "⊢ ∀ {a b : Bool}, (a < b ∧ ∀ ⦃c : Bool⦄, a < c → ¬c < b) ↔ a < b",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Bool.instDecidableForallOfDecidablePred",
"of_decide_eq_true",
"id",
"forall_prop_decidable",
"Bool.instLT",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Order.Cover | {
"line": 597,
"column": 36
} | {
"line": 597,
"column": 59
} | {
"line": 597,
"column": 60
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : PartialOrder α\ninst✝ : PartialOrder β\na : α\nb₁ b₂ : β\n⊢ (a, b₁) ⩿ (a, b₂) ∧ (a, b₁) < (a, b₂) ↔ b₁ ⩿ b₂ ∧ b₁ < b₂",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"PartialOrder.t... | [
"α : Type u_1\nβ : Type u_2\ninst✝¹ : PartialOrder α\ninst✝ : PartialOrder β\na : α\nb₁ b₂ : β\n⊢ b₁ ⩿ b₂ ∧ (a, b₁) < (a, b₂) ↔ b₁ ⩿ b₂ ∧ b₁ < b₂"
] | mk_wcovBy_mk_iff_right, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Order.Preorder.Finite | {
"line": 129,
"column": 2
} | {
"line": 129,
"column": 16
} | {
"line": 130,
"column": 2
} | [
{
"pp": "case inl\nα : Type u_2\ninst✝ : LinearOrder α\nhs : ∅.Finite\nhs' : IsCofinal ∅\n⊢ ∃ t, t.Subsingleton ∧ IsCofinal t",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Set.subsingleton_empty._simp_1",
"PartialOrder.toPreorder",
"Pre... | [
"case inr\nα : Type u_2\ninst✝ : LinearOrder α\ns : Set α\nhs : s.Finite\nhs' : IsCofinal s\nhn : s.Nonempty\n⊢ ∃ t, t.Subsingleton ∧ IsCofinal t"
] | · use ∅; simpa | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.Lattice.Nat | {
"line": 199,
"column": 92
} | {
"line": 200,
"column": 43
} | {
"line": 202,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : CompleteLattice α\nu : ℕ → α\nn : ℕ\n⊢ ⨆ k, ⨆ (_ : k ≤ n + 1), u k = (⨆ k, ⨆ (_ : k ≤ n), u k) ⊔ u (n + 1)",
"ppTerm": "?m.36",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Iff.of_eq",
"congrArg",
"iSup",
... | [] | by
simp_rw [← Nat.lt_succ_iff, iSup_lt_succ] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.WellQuasiOrder | {
"line": 60,
"column": 2
} | {
"line": 60,
"column": 30
} | {
"line": 62,
"column": 0
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ninst✝¹ : Finite α\ninst✝ : Std.Refl r\nf : ℕ → α\nm n : ℕ\nh : m < n\nhf : f m = f n\n⊢ ∃ m n, m < n ∧ r (f m) (f n)",
"ppTerm": "?m.38",
"assigned": true,
"usedConstants": [
"Exists",
"Eq.rec",
"And",
"Nat",
"And.intro",
"... | [] | exact ⟨m, n, h, hf ▸ refl _⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.Interval.Finset.Basic | {
"line": 355,
"column": 50
} | {
"line": 356,
"column": 21
} | {
"line": 358,
"column": 0
} | [
{
"pp": "α : Type u_2\na b : α\ninst✝¹ : Preorder α\ninst✝ : LocallyFiniteOrderTop α\n⊢ Ici a ⊆ Ici b ↔ b ≤ a",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Set.Ici",
"congrArg",
"Finset",
"PartialOrder.toPreorder",
"Set.Ici_subset_Ici._simp_1",
"Preor... | [] | by
simp [← coe_subset] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Interval.Finset.Basic | {
"line": 418,
"column": 50
} | {
"line": 419,
"column": 21
} | {
"line": 421,
"column": 0
} | [
{
"pp": "α : Type u_2\na b : α\ninst✝¹ : Preorder α\ninst✝ : LocallyFiniteOrderBot α\n⊢ Iic a ⊆ Iic b ↔ a ≤ b",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Finset.coe_Iic",
"congrArg",
"Finset",
"_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Iic_subset_Ii... | [] | by
simp [← coe_subset] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Interval.Finset.Defs | {
"line": 985,
"column": 6
} | {
"line": 985,
"column": 13
} | {
"line": 985,
"column": 13
} | [
{
"pp": "α : Type u_1\ninst✝² : Preorder α\np : α → Prop\ninst✝¹ : DecidablePred p\ninst✝ : LocallyFiniteOrder α\na b : Subtype p\nhp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x\nx : α\nhx : x ∈ Ioc ↑a ↑b\n⊢ p x",
"ppTerm": "?m.41",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
... | [
"α : Type u_1\ninst✝² : Preorder α\np : α → Prop\ninst✝¹ : DecidablePred p\ninst✝ : LocallyFiniteOrder α\na b : Subtype p\nhp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x\nx : α\nhx : ↑a < x ∧ x ≤ ↑b\n⊢ p x"
] | mem_Ioc | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Submonoid.Pointwise | {
"line": 48,
"column": 86
} | {
"line": 49,
"column": 26
} | {
"line": 51,
"column": 0
} | [
{
"pp": "M : Type u_3\nS : Type u_6\ninst✝² : Monoid M\ninst✝¹ : SetLike S M\ninst✝ : SubmonoidClass S M\nH : S\n⊢ ↑H * ↑H = ↑H",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Set.ext",
"Eq.mpr",
"SetLike.mem_coe._simp_1",
"MulOne.toOne",
"HMul.hMul",
"M... | [] | by
aesop (add simp mem_mul) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.WellFoundedSet | {
"line": 80,
"column": 76
} | {
"line": 91,
"column": 58
} | {
"line": 93,
"column": 0
} | [
{
"pp": "α : Type u_2\nr : α → α → Prop\ns : Set α\n⊢ s.WellFoundedOn r ↔ WellFounded fun a b ↦ r a b ∧ a ∈ s ∧ b ∈ s",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"RelEmbedding.mk",
"False",
"and_true",
"Subtype.preimage_coe_nonempty",
"congr... | [] | by
have f : RelEmbedding (Subrel r (· ∈ s)) fun a b : α => r a b ∧ a ∈ s ∧ b ∈ s :=
⟨⟨(↑), Subtype.coe_injective⟩, by simp⟩
refine ⟨fun h => ?_, f.wellFounded⟩
rw [WellFounded.wellFounded_iff_has_min]
intro t ht
by_cases hst : (s ∩ t).Nonempty
· rw [← Subtype.preimage_coe_nonempty] at hst
rcases h.h... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.WellFoundedSet | {
"line": 285,
"column": 2
} | {
"line": 285,
"column": 82
} | {
"line": 286,
"column": 2
} | [
{
"pp": "α : Type u_2\nr : α → α → Prop\ns t : Set α\nhs : s.PartiallyWellOrderedOn r\nht : t.PartiallyWellOrderedOn r\nf : ℕ → { x // x ∈ s ∪ t }\n⊢ ∃ m n, m < n ∧ Subrel r (fun x ↦ x ∈ s ∪ t) (f m) (f n)",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"Membership.mem",
"Exists... | [
"case inl\nα : Type u_2\nr : α → α → Prop\ns t : Set α\nhs : s.PartiallyWellOrderedOn r\nht : t.PartiallyWellOrderedOn r\nf : ℕ → { x // x ∈ s ∪ t }\ng : ℕ ↪o ℕ\nhgs : ∀ (n : ℕ), ↑(f (g n)) ∈ s\n⊢ ∃ m n, m < n ∧ Subrel r (fun x ↦ x ∈ s ∪ t) (f m) (f n)",
"case inr\nα : Type u_2\nr : α → α → Prop\ns t : Set α\nhs ... | obtain ⟨g, hgs | hgt⟩ := Nat.exists_subseq_of_forall_mem_union _ fun x ↦ (f x).2 | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Order.WellFoundedSet | {
"line": 345,
"column": 2
} | {
"line": 345,
"column": 15
} | {
"line": 346,
"column": 2
} | [
{
"pp": "α : Type u_2\nr : α → α → Prop\ns : Set α\ninst✝¹ : Std.Refl r\ninst✝ : Std.Symm r\n⊢ (∀ t ⊆ s, IsAntichain r t → t.Finite) → ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ s) → ∃ m n, m < n ∧ r (f m) (f n)",
"ppTerm": "?m.27",
"assigned": true,
"usedConstants": [
"Set.Finite",
"Membership.me... | [
"α : Type u_2\nr : α → α → Prop\ns : Set α\ninst✝¹ : Std.Refl r\ninst✝ : Std.Symm r\nhs : ∀ t ⊆ s, IsAntichain r t → t.Finite\nf : ℕ → α\nhf : ∀ (n : ℕ), f n ∈ s\n⊢ ∃ m n, m < n ∧ r (f m) (f n)"
] | intro hs f hf | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Order.Interval.Finset.Basic | {
"line": 1016,
"column": 83
} | {
"line": 1018,
"column": 82
} | {
"line": 1020,
"column": 0
} | [
{
"pp": "α : Type u_2\ninst✝¹ : DistribLattice α\ninst✝ : LocallyFiniteOrder α\na b c : α\nh : (fun b ↦ [[b, a]]) b = (fun b ↦ [[b, a]]) c\n⊢ b = c",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"congrArg",
"Finset",
"Membership.mem",
"Eq.mp",
... | [] | by
rw [Finset.ext_iff] at h
exact eq_of_mem_uIcc_of_mem_uIcc ((h _).1 left_mem_uIcc) ((h _).2 left_mem_uIcc) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.WellFoundedSet | {
"line": 755,
"column": 2
} | {
"line": 756,
"column": 84
} | {
"line": 757,
"column": 2
} | [
{
"pp": "α : Type u_2\nr : α → α → Prop\ns : Set α\nhs : s.PartiallyWellOrderedOn r\nf : ℕ → α\nhf : ∀ (x : ℕ), ∃ y ∈ f ⁻¹' s, x < y\n⊢ ∃ m n, m < n ∧ r (f m) (f n)",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"StrictMono",
"PartialOrder.toPreorder",
... | [
"α : Type u_2\nr : α → α → Prop\ns : Set α\nhs : s.PartiallyWellOrderedOn r\nf : ℕ → α\nhf : ∀ (x : ℕ), ∃ y ∈ f ⁻¹' s, x < y\nφ : ℕ → ℕ\nhφm : StrictMono φ\nhφs : ∀ (n : ℕ), φ n ∈ f ⁻¹' s\n⊢ ∃ m n, m < n ∧ r (f m) (f n)"
] | obtain ⟨φ, hφm, hφs⟩ := Nat.exists_strictMono_subsequence
fun n ↦ (hf n).casesOn fun m h ↦ h.casesOn fun hs hmn ↦ Exists.intro m ⟨hmn, hs⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Algebra.Group.Center | {
"line": 267,
"column": 2
} | {
"line": 267,
"column": 37
} | {
"line": 269,
"column": 0
} | [
{
"pp": "M : Type u_1\ninst✝¹ : Monoid M\na : M\ninst✝ : Invertible a\nha : ∀ (g : M), g * a = a * g\n⊢ ∀ (g : M), g * ⅟a = ⅟a * g",
"ppTerm": "?m.27",
"assigned": true,
"usedConstants": [
"Commute.invOf_right"
],
"usedFVars": [
"M",
"inst✝¹",
"a",
"inst✝",
... | [] | exact (Commute.invOf_right <| ha ·) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Group.Center | {
"line": 282,
"column": 2
} | {
"line": 282,
"column": 21
} | {
"line": 283,
"column": 2
} | [
{
"pp": "M : Type u_1\ninst✝ : DivisionMonoid M\na b : M\nha : a ∈ center M\nhb : b ∈ center M\n⊢ a / b ∈ center M",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg"... | [
"M : Type u_1\ninst✝ : DivisionMonoid M\na b : M\nha : a ∈ center M\nhb : b ∈ center M\n⊢ a * b⁻¹ ∈ center M"
] | rw [div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.WellFoundedSet | {
"line": 901,
"column": 8
} | {
"line": 901,
"column": 33
} | {
"line": 903,
"column": 0
} | [
{
"pp": "case h.refine_2\nα : Type u_2\nβ : Type u_3\ninst✝¹ : PartialOrder α\ninst✝ : Preorder β\ns : Set (Lex (α × β))\nhα : ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ (fun x ↦ (ofLex x).1) '' s) → ∃ g, Monotone (f ∘ ⇑g)\nhβ : ∀ (a : α), {y | toLex (a, y) ∈ s}.IsPWO\nf : ℕ → Lex (α × β)\nhf : ∀ (n : ℕ), f n ∈ s\ng : ℕ ... | [] | exact hg' (Nat.zero_le 1) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.WellFoundedSet | {
"line": 901,
"column": 8
} | {
"line": 901,
"column": 33
} | {
"line": 903,
"column": 0
} | [
{
"pp": "case h.refine_2\nα : Type u_2\nβ : Type u_3\ninst✝¹ : PartialOrder α\ninst✝ : Preorder β\ns : Set (Lex (α × β))\nhα : ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ (fun x ↦ (ofLex x).1) '' s) → ∃ g, Monotone (f ∘ ⇑g)\nhβ : ∀ (a : α), {y | toLex (a, y) ∈ s}.IsPWO\nf : ℕ → Lex (α × β)\nhf : ∀ (n : ℕ), f n ∈ s\ng : ℕ ... | [] | exact hg' (Nat.zero_le 1) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.WellFoundedSet | {
"line": 901,
"column": 8
} | {
"line": 901,
"column": 33
} | {
"line": 903,
"column": 0
} | [
{
"pp": "case h.refine_2\nα : Type u_2\nβ : Type u_3\ninst✝¹ : PartialOrder α\ninst✝ : Preorder β\ns : Set (Lex (α × β))\nhα : ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ (fun x ↦ (ofLex x).1) '' s) → ∃ g, Monotone (f ∘ ⇑g)\nhβ : ∀ (a : α), {y | toLex (a, y) ∈ s}.IsPWO\nf : ℕ → Lex (α × β)\nhf : ∀ (n : ℕ), f n ∈ s\ng : ℕ ... | [] | exact hg' (Nat.zero_le 1) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.WellFoundedSet | {
"line": 917,
"column": 2
} | {
"line": 918,
"column": 34
} | {
"line": 919,
"column": 2
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝¹ : Preorder α\ninst✝ : Preorder β\ns : Set (Lex (α × β))\nhαβ : s.IsPWO\na : α\nf : Lex (α × β) → β := fun x ↦ (ofLex x).2\nh : {y | toLex (a, y) ∈ s} = f '' (s ∩ (fun x ↦ (ofLex x).1) ⁻¹' {a})\nb c : Lex (α × β)\nhbc : b ≤ c\nhb : (ofLex b).1 = a\nhc : (ofLex c).1 = a... | [
"α : Type u_2\nβ : Type u_3\ninst✝¹ : Preorder α\ninst✝ : Preorder β\ns : Set (Lex (α × β))\nhαβ : s.IsPWO\na : α\nf : Lex (α × β) → β := fun x ↦ (ofLex x).2\nh : {y | toLex (a, y) ∈ s} = f '' (s ∩ (fun x ↦ (ofLex x).1) ⁻¹' {a})\nb c : Lex (α × β)\nhbc : b ≤ c\nhb : (ofLex b).1 = a\nhc : (ofLex c).1 = a\nthis : (of... | have : (ofLex b).1 < (ofLex c).1 ∨ (ofLex b).1 = (ofLex c).1 ∧ f b ≤ f c :=
Prod.Lex.toLex_le_toLex.mp hbc | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Finset.NoncommProd | {
"line": 175,
"column": 2
} | {
"line": 175,
"column": 30
} | {
"line": 176,
"column": 2
} | [
{
"pp": "F : Type u_1\nα : Type u_3\nβ : Type u_4\ninst✝³ : Monoid α\ninst✝² : Monoid β\ninst✝¹ : FunLike F α β\ninst✝ : MulHomClass F α β\ns : Multiset α\ncomm : {x | x ∈ s}.Pairwise Commute\nf : F\n⊢ {x | x ∈ map (⇑f) s}.Pairwise Commute",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
... | [
"F : Type u_1\nα : Type u_3\nβ : Type u_4\ninst✝³ : Monoid α\ninst✝² : Monoid β\ninst✝¹ : FunLike F α β\ninst✝ : MulHomClass F α β\ns : Multiset α\ncomm : {x | x ∈ s}.Pairwise Commute\nf : F\n⊢ {x | ∃ a ∈ s, f a = x}.Pairwise Commute"
] | simp only [Multiset.mem_map] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.