module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 365
values | kind stringclasses 368
values |
|---|---|---|---|---|---|---|
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1000,
"column": 69
} | {
"line": 1001,
"column": 42
} | [
{
"pp": "n : ℕ\nα : Fin (n + 1) → Type u_3\ninst✝ : (i : Fin (n + 1)) → Preorder (α i)\ni : Fin (n + 1)\nx : α i\np : (j : Fin n) → α (i.succAbove j)\nq : (j : Fin (n + 1)) → α j\n⊢ i.insertNth x p ≤ q ↔ x ≤ q i ∧ p ≤ fun j ↦ q (i.succAbove j)",
"usedConstants": [
"Fin.succAbove",
"congrArg",
... | by
simp [Pi.le_def, forall_iff_succAbove i] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1004,
"column": 71
} | {
"line": 1005,
"column": 42
} | [
{
"pp": "n : ℕ\nα : Fin (n + 1) → Type u_3\ninst✝ : (i : Fin (n + 1)) → Preorder (α i)\ni : Fin (n + 1)\nx : α i\np : (j : Fin n) → α (i.succAbove j)\nq : (j : Fin (n + 1)) → α j\n⊢ q ≤ i.insertNth x p ↔ q i ≤ x ∧ (fun j ↦ q (i.succAbove j)) ≤ p",
"usedConstants": [
"Fin.succAbove",
"congrArg",
... | by
simp [Pi.le_def, forall_iff_succAbove i] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Multiset.Fold | {
"line": 64,
"column": 6
} | {
"line": 64,
"column": 23
} | [
{
"pp": "α : Type u_1\nop : α → α → α\nhc : Std.Commutative op\nha : Std.Associative op\nb a : α\ns : Multiset α\n⊢ fold op b (a ::ₘ s) = fold op (op a b) s",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Multiset.cons",
"id",
"Multiset.fold_cons'_right",
"Eq",
"Multise... | fold_cons'_right, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1271,
"column": 6
} | {
"line": 1271,
"column": 22
} | [
{
"pp": "case inl.h\nn : ℕ\nα : Sort u_1\nj : Fin (n + 1)\nop : α → α → α\ng : Fin (n + 1) → α\nk : Fin n\nhjk : ↑j ≠ ↑k\nh : ↑k < ↑j\n⊢ k.castSucc < j",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"instOfNatNat",
"Fin.val",
"instHAdd",
"Fin.lt_def",
"HAdd.... | rwa [Fin.lt_def] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1271,
"column": 6
} | {
"line": 1271,
"column": 22
} | [
{
"pp": "case inl.h\nn : ℕ\nα : Sort u_1\nj : Fin (n + 1)\nop : α → α → α\ng : Fin (n + 1) → α\nk : Fin n\nhjk : ↑j ≠ ↑k\nh : ↑k < ↑j\n⊢ k.castSucc < j",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"instOfNatNat",
"Fin.val",
"instHAdd",
"Fin.lt_def",
"HAdd.... | rwa [Fin.lt_def] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.Tuple.Basic | {
"line": 1271,
"column": 6
} | {
"line": 1271,
"column": 22
} | [
{
"pp": "case inl.h\nn : ℕ\nα : Sort u_1\nj : Fin (n + 1)\nop : α → α → α\ng : Fin (n + 1) → α\nk : Fin n\nhjk : ↑j ≠ ↑k\nh : ↑k < ↑j\n⊢ k.castSucc < j",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"instOfNatNat",
"Fin.val",
"instHAdd",
"Fin.lt_def",
"HAdd.... | rwa [Fin.lt_def] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Fold | {
"line": 138,
"column": 8
} | {
"line": 138,
"column": 88
} | [
{
"pp": "case neg\nα : Type u_1\nβ : Type u_2\nop : β → β → β\nhc : Std.Commutative op\nha : Std.Associative op\nf : α → β\nb : β\ns✝ : Finset α\ng : α → β\nhb : op b b = b\np : α → Prop\ninst✝ : DecidablePred p\nx : α\ns : Finset α\nhx : x ∉ s\nIH : fold op b (fun i ↦ if p i then f i else g i) s = op (fold op ... | simp [Finset.filter_insert, h, Finset.fold_insert this, IH, ← ha.assoc, hc.comm] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Set.Finite.Basic | {
"line": 936,
"column": 2
} | {
"line": 936,
"column": 42
} | [
{
"pp": "α : Type u\ninst✝ : LinearOrder α\nh : ∀ ⦃x y z : α⦄, x < y → y < z → False\na✝ : Nontrivial α\n⊢ Finite α",
"usedConstants": [
"exists_pair_ne"
]
}
] | rcases exists_pair_ne α with ⟨x, y, hne⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.List.Rotate | {
"line": 59,
"column": 42
} | {
"line": 59,
"column": 69
} | [
{
"pp": "α : Type u\na : α\nl : List α\nn : ℕ\n⊢ ((l ++ [a]).rotate' n).length = (a :: l).length",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"List.cons",
"instHAppendOfAppend",
"List",
"List.rotate'",
"Nat",
"List.instAppend",
"Eq",
"Lis... | length_rotate' (l ++ [a]) n | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.BigOperators.Group.Multiset.Defs | {
"line": 116,
"column": 4
} | {
"line": 116,
"column": 29
} | [
{
"pp": "case cons\nM : Type u_3\ninst✝ : CommMonoid M\ns✝ : Multiset M\np : M → Prop\np_mul : ∀ (a b : M), p a → p b → p (a * b)\na : M\ns : Multiset M\nhsa : s ≠ ∅ → (∀ (a : M), a ∈ s → p a) → p s.prod\nhs : a ::ₘ s ≠ ∅\np_s : ∀ (a_1 : M), a_1 ∈ a ::ₘ s → p a_1\n⊢ p (a * s.prod)",
"usedConstants": [
... | by_cases hs_empty : s = ∅ | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Data.List.Rotate | {
"line": 135,
"column": 6
} | {
"line": 135,
"column": 52
} | [
{
"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",
"id",
"LT.lt.le",
"Nat.instMod",
"instHMod",
"Nat.mod_lt",
"instHAppendOfAppend",
... | ← rotate_eq_drop_append_take (n.mod_lt hl).le, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Enum | {
"line": 31,
"column": 2
} | {
"line": 31,
"column": 67
} | [
{
"pp": "α : Type u_1\nl : List α\nn : ℕ\np : α × ℕ → Prop\n⊢ (∃ x, x ∈ l.zipIdx n ∧ p x) ↔ ∃ i x, p (l[i], n + i)",
"usedConstants": [
"Iff.mpr",
"List.getElem_zipIdx._proof_1",
"Iff.of_eq",
"congrArg",
"Membership.mem",
"Exists",
"Prod.mk",
"List.length_zipI... | simp only [exists_mem_iff_getElem, getElem_zipIdx, length_zipIdx] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Enum | {
"line": 31,
"column": 2
} | {
"line": 31,
"column": 67
} | [
{
"pp": "α : Type u_1\nl : List α\nn : ℕ\np : α × ℕ → Prop\n⊢ (∃ x, x ∈ l.zipIdx n ∧ p x) ↔ ∃ i x, p (l[i], n + i)",
"usedConstants": [
"Iff.mpr",
"List.getElem_zipIdx._proof_1",
"Iff.of_eq",
"congrArg",
"Membership.mem",
"Exists",
"Prod.mk",
"List.length_zipI... | simp only [exists_mem_iff_getElem, getElem_zipIdx, length_zipIdx] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Enum | {
"line": 31,
"column": 2
} | {
"line": 31,
"column": 67
} | [
{
"pp": "α : Type u_1\nl : List α\nn : ℕ\np : α × ℕ → Prop\n⊢ (∃ x, x ∈ l.zipIdx n ∧ p x) ↔ ∃ i x, p (l[i], n + i)",
"usedConstants": [
"Iff.mpr",
"List.getElem_zipIdx._proof_1",
"Iff.of_eq",
"congrArg",
"Membership.mem",
"Exists",
"Prod.mk",
"List.length_zipI... | simp only [exists_mem_iff_getElem, getElem_zipIdx, length_zipIdx] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Pi | {
"line": 71,
"column": 2
} | {
"line": 71,
"column": 23
} | [
{
"pp": "case neg\nα : Type u_1\ninst✝ : DecidableEq α\nδ : α → Sort u_2\nm : Multiset α\na : α\nf : (a' : α) → a' ∈ a ::ₘ m → δ a'\na' : α\nh' : a' ∈ a ::ₘ m\nh : ¬a' = a\n⊢ cons m a (f a ⋯) (fun a' ha' ↦ f a' ⋯) a' h' = f a' h'",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Multiset.mem_con... | · rw [Pi.cons_ne _ h] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Group.Subsemigroup.Basic | {
"line": 231,
"column": 6
} | {
"line": 231,
"column": 17
} | [
{
"pp": "M : Type u_1\ninst✝ : Mul M\nm : M\np : Subsemigroup M\n⊢ closure {m} ≤ p ↔ m ∈ p",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Subsemigroup.instPartialOrder",
"Preorder.toLE",
"Membership.mem",
"Set.instSingletonSet",
"id",
... | closure_le, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Pi.Lemmas | {
"line": 471,
"column": 2
} | {
"line": 471,
"column": 46
} | [
{
"pp": "α : Type u_4\nβ : α → Type u_5\nγ : (a : α) → β a → Type u_6\ninst✝² : DecidableEq α\ninst✝¹ : (a : α) → DecidableEq (β a)\ninst✝ : (a : α) → (b : β a) → One (γ a b)\na : α\nb : β a\nx : γ a b\n⊢ uncurry (Pi.mulSingle a (Pi.mulSingle b x)) = Pi.mulSingle ⟨a, b⟩ x",
"usedConstants": [
"Eq.mpr"... | rw [← curry_mulSingle ⟨a, b⟩, uncurry_curry] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Pi.Lemmas | {
"line": 471,
"column": 2
} | {
"line": 471,
"column": 46
} | [
{
"pp": "α : Type u_4\nβ : α → Type u_5\nγ : (a : α) → β a → Type u_6\ninst✝² : DecidableEq α\ninst✝¹ : (a : α) → DecidableEq (β a)\ninst✝ : (a : α) → (b : β a) → One (γ a b)\na : α\nb : β a\nx : γ a b\n⊢ uncurry (Pi.mulSingle a (Pi.mulSingle b x)) = Pi.mulSingle ⟨a, b⟩ x",
"usedConstants": [
"Eq.mpr"... | rw [← curry_mulSingle ⟨a, b⟩, uncurry_curry] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Pi.Lemmas | {
"line": 471,
"column": 2
} | {
"line": 471,
"column": 46
} | [
{
"pp": "α : Type u_4\nβ : α → Type u_5\nγ : (a : α) → β a → Type u_6\ninst✝² : DecidableEq α\ninst✝¹ : (a : α) → DecidableEq (β a)\ninst✝ : (a : α) → (b : β a) → One (γ a b)\na : α\nb : β a\nx : γ a b\n⊢ uncurry (Pi.mulSingle a (Pi.mulSingle b x)) = Pi.mulSingle ⟨a, b⟩ x",
"usedConstants": [
"Eq.mpr"... | rw [← curry_mulSingle ⟨a, b⟩, uncurry_curry] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Pointwise.Set.Basic | {
"line": 869,
"column": 61
} | {
"line": 870,
"column": 75
} | [
{
"pp": "α : Type u_2\ninst✝ : Group α\ns t : Set α\n⊢ 1 ∈ s / t ↔ ¬Disjoint s t",
"usedConstants": [
"instHDiv",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"_private.Mathlib.Algebra.Group.Pointwise.Set.Basic.0.Set.one_mem_div_iff._simp_1_2",
"congrArg",
"Parti... | by
simp [not_disjoint_iff_nonempty_inter, mem_div, div_eq_one, Set.Nonempty] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Pointwise.Set.Basic | {
"line": 1015,
"column": 2
} | {
"line": 1018,
"column": 27
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝³ : Group α\ninst✝² : DivisionMonoid β\ninst✝¹ : FunLike F α β\ninst✝ : MonoidHomClass F α β\nm : F\ns t : Set β\nhs : s ⊆ range ⇑m\nht : t ⊆ range ⇑m\n⊢ s / t ⊆ range ⇑m",
"usedConstants": [
"instHDiv",
"Membership.mem",
"Exists",
... | rintro _ ⟨a, ha, b, hb, rfl⟩
obtain ⟨a, rfl⟩ := hs ha
obtain ⟨b, rfl⟩ := ht hb
exact ⟨a / b, map_div ..⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Pointwise.Set.Basic | {
"line": 1015,
"column": 2
} | {
"line": 1018,
"column": 27
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝³ : Group α\ninst✝² : DivisionMonoid β\ninst✝¹ : FunLike F α β\ninst✝ : MonoidHomClass F α β\nm : F\ns t : Set β\nhs : s ⊆ range ⇑m\nht : t ⊆ range ⇑m\n⊢ s / t ⊆ range ⇑m",
"usedConstants": [
"instHDiv",
"Membership.mem",
"Exists",
... | rintro _ ⟨a, ha, b, hb, rfl⟩
obtain ⟨a, rfl⟩ := hs ha
obtain ⟨b, rfl⟩ := ht hb
exact ⟨a / b, map_div ..⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Submonoid.Basic | {
"line": 265,
"column": 26
} | {
"line": 265,
"column": 36
} | [
{
"pp": "M : Type u_1\ninst✝ : MulOneClass M\nN N' : Submonoid M\n⊢ N ⊔ N' = closure ↑N ⊔ closure ↑N'",
"usedConstants": [
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"congrArg",
"SemilatticeSup.toMax",
"Submonoid.closure_eq",
"Submonoid.instCompleteLattice",... | closure_eq | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Group.Submonoid.Basic | {
"line": 273,
"column": 6
} | {
"line": 273,
"column": 17
} | [
{
"pp": "M : Type u_1\ninst✝ : MulOneClass M\nm : M\np : Submonoid M\n⊢ closure {m} ≤ p ↔ m ∈ p",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Set.instSingletonSet",
"id",
"HasSubset.Subset",
"LE... | closure_le, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Set.Lattice.Image | {
"line": 220,
"column": 2
} | {
"line": 220,
"column": 41
} | [
{
"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 : β\nhy : y ∈ ⋂ i, f '' s i\n⊢ y ∈ f '' ⋂ i, s i",
"usedConstants": [
"_private.Mathlib.Data.Set.Lattice.Image.0.Set.InjOn.image_iInter_eq._simp_1_2",
... | simp only [mem_iInter, mem_image] at hy | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Group.Subgroup.Lattice | {
"line": 450,
"column": 26
} | {
"line": 450,
"column": 36
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH H' : Subgroup G\n⊢ H ⊔ H' = closure ↑H ⊔ closure ↑H'",
"usedConstants": [
"Subgroup.closure_eq",
"Lattice.toSemilatticeSup",
"Subgroup.closure",
"CompleteLattice.toLattice",
"congrArg",
"SemilatticeSup.toMax",
"Subgroup",
... | closure_eq | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Group.Subgroup.Lattice | {
"line": 461,
"column": 75
} | {
"line": 461,
"column": 85
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nι : Sort u_2\np : ι → Subgroup G\n⊢ ⨆ i, p i = ⨆ i, closure ↑(p i)",
"usedConstants": [
"Subgroup.closure_eq",
"Subgroup.closure",
"congrArg",
"iSup",
"Subgroup",
"funext",
"SetLike.coe",
"True",
"eq_self",
"... | closure_eq | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Group.Subgroup.Lattice | {
"line": 468,
"column": 92
} | {
"line": 479,
"column": 26
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nx y : G\n⊢ y ∈ closure {x} ↔ ∃ n, x ^ n = y",
"usedConstants": [
"Set.mem_singleton",
"Eq.mpr",
"Subgroup.instSubgroupClass",
"zpow_add",
"InvOneClass.toOne",
"Set.eq_of_mem_singleton",
"HMul.hMul",
"Subgroup.closure",
... | by
refine
⟨fun hy => closure_induction ?_ ?_ ?_ ?_ hy, fun ⟨n, hn⟩ =>
hn ▸ zpow_mem (subset_closure <| mem_singleton x) n⟩
· intro y hy
rw [eq_of_mem_singleton hy]
exact ⟨1, zpow_one x⟩
· exact ⟨0, zpow_zero x⟩
· rintro _ _ _ _ ⟨n, rfl⟩ ⟨m, rfl⟩
exact ⟨n + m, zpow_add x n m⟩
rintro _ _ ⟨... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Subgroup.Ker | {
"line": 130,
"column": 39
} | {
"line": 130,
"column": 65
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Group G\nN : Type u_7\ninst✝ : Group N\nf : G →* N\n⊢ ↑f.range = ↑⊤ ↔ Set.range ⇑f = Set.univ",
"usedConstants": [
"Eq.mpr",
"MonoidHom.range",
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"congrArg",
"Set.univ",
... | by rw [coe_range, coe_top] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Subgroup.Map | {
"line": 389,
"column": 10
} | {
"line": 390,
"column": 30
} | [
{
"pp": "G : Type u_1\nG' : Type u_2\ninst✝² : Group G\ninst✝¹ : Group G'\nH : Subgroup G\nf : G' →* G\nhf : Injective ⇑f\ninst✝ : IsMulCommutative ↥H\na b : ↥(comap f H)\nthis : ⟨f ↑a, ⋯⟩ * ⟨f ↑b, ⋯⟩ = ⟨f ↑b, ⋯⟩ * ⟨f ↑a, ⋯⟩\n⊢ ↑(a * b) = ↑(b * a)",
"usedConstants": [
"MonoidHom.instMonoidHomClass",
... | rwa [Subtype.ext_iff, coe_mul, coe_mul, coe_mk, coe_mk, ← map_mul, ← map_mul,
hf.eq_iff] at this | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Algebra.Group.Submonoid.Operations | {
"line": 808,
"column": 2
} | {
"line": 808,
"column": 17
} | [
{
"pp": "case h\nM : Type u_1\nN : Type u_2\ninst✝¹ : MulOneClass M\ninst✝ : MulOneClass N\nx✝ : M\n⊢ x✝ ∈ mker 1 ↔ x✝ ∈ ⊤",
"usedConstants": [
"MonoidHom.instMonoidHomClass",
"MulOne.toOne",
"MonoidHom.instFunLike",
"MonoidHom.mker",
"MonoidHom",
"congrArg",
"Membe... | simp [mem_mker] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Group.Submonoid.Operations | {
"line": 824,
"column": 2
} | {
"line": 824,
"column": 17
} | [
{
"pp": "case h\nM : Type u_1\nN : Type u_2\ninst✝¹ : MulOneClass M\ninst✝ : MulOneClass N\nx : M\n⊢ x ∈ mker (inl M N) ↔ x ∈ ⊥",
"usedConstants": [
"MonoidHom.instMonoidHomClass",
"MulOne.toOne",
"MonoidHom.instFunLike",
"MonoidHom.mker",
"and_true",
"MonoidHom",
"... | simp [mem_mker] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Group.Submonoid.Operations | {
"line": 829,
"column": 2
} | {
"line": 829,
"column": 17
} | [
{
"pp": "case h\nM : Type u_1\nN : Type u_2\ninst✝¹ : MulOneClass M\ninst✝ : MulOneClass N\nx : N\n⊢ x ∈ mker (inr M N) ↔ x ∈ ⊥",
"usedConstants": [
"MonoidHom.instMonoidHomClass",
"MulOne.toOne",
"MonoidHom.instFunLike",
"MonoidHom.mker",
"MonoidHom.inr",
"MonoidHom",
... | simp [mem_mker] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Nat.Bits | {
"line": 165,
"column": 57
} | {
"line": 165,
"column": 70
} | [
{
"pp": "b : Bool\nn : ℕ\n⊢ b.toNat / 2 + n = n",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"congrArg",
"Bool.toNat",
"id",
"HDiv.hDiv",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Nat.instDiv",
"instAddNat",
"Nat.div_eq_of_lt... | div_eq_of_lt, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Pairing | {
"line": 136,
"column": 75
} | {
"line": 138,
"column": 56
} | [
{
"pp": "m n : ℕ\n⊢ pair m n < (max m n + 1) ^ 2",
"usedConstants": [
"_private.Mathlib.Data.Nat.Pairing.0.Nat.pair_lt_max_add_one_sq._simp_1_2",
"instPowNat",
"Eq.mpr",
"False",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"HMul.hMul",
"instDistribLatticeNat"... | by
simp only [pair, Nat.pow_two, Nat.mul_add, Nat.add_mul, Nat.mul_one, Nat.one_mul, Nat.add_assoc]
split_ifs <;> simp [Nat.le_of_lt, not_lt.1, *] <;> lia | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Subgroup.Basic | {
"line": 882,
"column": 2
} | {
"line": 882,
"column": 43
} | [
{
"pp": "case conj_mem\nG : Type u_1\ninst✝ : Group G\nι : Sort u_6\na : ι → Subgroup G\nnorm : ∀ (i : ι), (a i).Normal\ng : G\ng_in_iInf : ∀ (i : ι), g ∈ a i\nh : G\ni : ι\n⊢ h * g * h⁻¹ ∈ a i",
"usedConstants": [
"Subgroup.Normal.conj_mem"
]
}
] | exact (norm i).conj_mem g (g_in_iInf i) h | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Group.Subgroup.ZPowers.Basic | {
"line": 122,
"column": 26
} | {
"line": 122,
"column": 37
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\ng : G\nH : Subgroup G\n⊢ closure {g} ≤ H ↔ g ∈ H",
"usedConstants": [
"Eq.mpr",
"Subgroup.closure",
"congrArg",
"PartialOrder.toPreorder",
"Subgroup.closure_le",
"Preorder.toLE",
"Membership.mem",
"Set.instSingletonSet",... | closure_le, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Idempotent | {
"line": 98,
"column": 4
} | {
"line": 99,
"column": 59
} | [
{
"pp": "M : Type u_1\ninst✝ : Monoid M\na : M\nh : IsUnit a\nidem : IsIdempotentElem a\n⊢ a = 1",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"mul_assoc",
"_private.Mathlib.Algebra.Group.Ide... | have ⟨q, eq⟩ := h.exists_left_inv
rw [← eq, ← idem.eq, ← mul_assoc, eq, one_mul, idem.eq] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Idempotent | {
"line": 98,
"column": 4
} | {
"line": 99,
"column": 59
} | [
{
"pp": "M : Type u_1\ninst✝ : Monoid M\na : M\nh : IsUnit a\nidem : IsIdempotentElem a\n⊢ a = 1",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"mul_assoc",
"_private.Mathlib.Algebra.Group.Ide... | have ⟨q, eq⟩ := h.exists_left_inv
rw [← eq, ← idem.eq, ← mul_assoc, eq, one_mul, idem.eq] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | {
"line": 337,
"column": 44
} | {
"line": 337,
"column": 75
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝¹ : Group α\ninst✝ : MulAction α β\ns : Set β\n⊢ (∀ ⦃i j : α⦄, ¬Disjoint ((j⁻¹ * i) • s) s → i = j) ↔ ∀ (a : α), (a • s ∩ s).Nonempty → a = 1",
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"instHSMul",
"InvOneClass.toOne",
"HMul.hMul... | not_disjoint_iff_nonempty_inter | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Sigma.Lex | {
"line": 89,
"column": 6
} | {
"line": 89,
"column": 23
} | [
{
"pp": "case left\nι : Type u_1\nα : ι → Type u_2\nr r₁ r₂ : ι → ι → Prop\ns s₁ s₂ : (i : ι) → α i → α i → Prop\na✝ b : (i : ι) × α i\ninst✝¹ : Std.Irrefl r\ninst✝ : ∀ (i : ι), Std.Irrefl (s i)\ni✝ : ι\na : α i✝\nhi : r i✝ i✝\n⊢ False",
"usedConstants": [
"irrefl"
]
}
] | exact irrefl _ hi | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Sigma.Lex | {
"line": 89,
"column": 6
} | {
"line": 89,
"column": 23
} | [
{
"pp": "case left\nι : Type u_1\nα : ι → Type u_2\nr r₁ r₂ : ι → ι → Prop\ns s₁ s₂ : (i : ι) → α i → α i → Prop\na✝ b : (i : ι) × α i\ninst✝¹ : Std.Irrefl r\ninst✝ : ∀ (i : ι), Std.Irrefl (s i)\ni✝ : ι\na : α i✝\nhi : r i✝ i✝\n⊢ False",
"usedConstants": [
"irrefl"
]
}
] | exact irrefl _ hi | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Sigma.Lex | {
"line": 89,
"column": 6
} | {
"line": 89,
"column": 23
} | [
{
"pp": "case left\nι : Type u_1\nα : ι → Type u_2\nr r₁ r₂ : ι → ι → Prop\ns s₁ s₂ : (i : ι) → α i → α i → Prop\na✝ b : (i : ι) × α i\ninst✝¹ : Std.Irrefl r\ninst✝ : ∀ (i : ι), Std.Irrefl (s i)\ni✝ : ι\na : α i✝\nhi : r i✝ i✝\n⊢ False",
"usedConstants": [
"irrefl"
]
}
] | exact irrefl _ hi | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sigma.Lex | {
"line": 131,
"column": 4
} | {
"line": 134,
"column": 50
} | [
{
"pp": "case inr.inl\nι : Type u_1\nα : ι → Type u_2\nr r₁ r₂ : ι → ι → Prop\ns s₁ s₂ : (i : ι) → α i → α i → Prop\na✝ b✝ : (i : ι) × α i\ninst✝¹ : Std.Trichotomous r\ninst✝ : ∀ (i : ι), Std.Trichotomous (s i)\ni : ι\na b : α i\n⊢ Lex r s ⟨i, a⟩ ⟨i, b⟩ ∨ ⟨i, a⟩ = ⟨i, b⟩ ∨ Lex r s ⟨i, b⟩ ⟨i, a⟩",
"usedConst... | · obtain hab | rfl | hba := trichotomous_of (s i) a b
· exact Or.inl (Lex.right _ _ hab)
· exact Or.inr (Or.inl rfl)
· exact Or.inr (Or.inr <| Lex.right _ _ hba) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Nat.Choose.Basic | {
"line": 144,
"column": 16
} | {
"line": 144,
"column": 51
} | [
{
"pp": "x✝ : ℕ\nhk : x✝ ≤ 0\n⊢ choose 0 x✝ * x✝! * (0 - x✝)! = 0!",
"usedConstants": [
"Nat.choose",
"HMul.hMul",
"Nat.mul_one",
"congrArg",
"HSub.hSub",
"instSubNat",
"instMulNat",
"instOfNatNat",
"Nat.sub_self",
"instHSub",
"Nat.factorial"... | by simp [Nat.eq_zero_of_le_zero hk] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 77,
"column": 2
} | {
"line": 81,
"column": 34
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝¹ : SemilatticeSup α\ninst✝ : OrderBot α\ns : Finset β\nf g : β → α\n⊢ s.sup (f ⊔ g) = s.sup f ⊔ s.sup g",
"usedConstants": [
"Eq.mpr",
"sup_sup_sup_comm",
"Finset.cons_induction",
"Finset.cons",
"congrArg",
"Finset",
"Order... | induction s using Finset.cons_induction with
| empty => rw [sup_empty, sup_empty, sup_empty, bot_sup_eq]
| cons _ _ _ ih =>
rw [sup_cons, sup_cons, sup_cons, ih]
exact sup_sup_sup_comm _ _ _ _ | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 77,
"column": 2
} | {
"line": 81,
"column": 34
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝¹ : SemilatticeSup α\ninst✝ : OrderBot α\ns : Finset β\nf g : β → α\n⊢ s.sup (f ⊔ g) = s.sup f ⊔ s.sup g",
"usedConstants": [
"Eq.mpr",
"sup_sup_sup_comm",
"Finset.cons_induction",
"Finset.cons",
"congrArg",
"Finset",
"Order... | induction s using Finset.cons_induction with
| empty => rw [sup_empty, sup_empty, sup_empty, bot_sup_eq]
| cons _ _ _ ih =>
rw [sup_cons, sup_cons, sup_cons, ih]
exact sup_sup_sup_comm _ _ _ _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 77,
"column": 2
} | {
"line": 81,
"column": 34
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝¹ : SemilatticeSup α\ninst✝ : OrderBot α\ns : Finset β\nf g : β → α\n⊢ s.sup (f ⊔ g) = s.sup f ⊔ s.sup g",
"usedConstants": [
"Eq.mpr",
"sup_sup_sup_comm",
"Finset.cons_induction",
"Finset.cons",
"congrArg",
"Finset",
"Order... | induction s using Finset.cons_induction with
| empty => rw [sup_empty, sup_empty, sup_empty, bot_sup_eq]
| cons _ _ _ ih =>
rw [sup_cons, sup_cons, sup_cons, ih]
exact sup_sup_sup_comm _ _ _ _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Powerset | {
"line": 319,
"column": 6
} | {
"line": 319,
"column": 58
} | [
{
"pp": "α : Type u_1\ns : Multiset α\nl : List α\nh : Nodup ⟦l⟧\n⊢ (powerset ⟦l⟧).Nodup",
"usedConstants": [
"List.sublists'",
"Eq.mpr",
"Multiset.powerset_coe'",
"Multiset.Nodup",
"congrArg",
"List.map",
"Multiset.powerset",
"Multiset",
"id",
"Qu... | simp only [quot_mk_to_coe, powerset_coe', coe_nodup] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 784,
"column": 2
} | {
"line": 784,
"column": 43
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nι : Type u_5\ninst✝³ : SemilatticeSup α\ninst✝² : SemilatticeSup β\ninst✝¹ : FunLike F α β\ninst✝ : SupHomClass F α β\nf : F\ns : Finset ι\nhs : s.Nonempty\ng : ι → α\n⊢ f (s.sup' hs g) = s.sup' hs (⇑f ∘ g)",
"usedConstants": [
"Finset",
"Functi... | refine hs.cons_induction ?_ ?_ <;> intros | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 912,
"column": 2
} | {
"line": 912,
"column": 43
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nι : Type u_5\ninst✝³ : SemilatticeInf α\ninst✝² : SemilatticeInf β\ninst✝¹ : FunLike F α β\ninst✝ : InfHomClass F α β\nf : F\ns : Finset ι\nhs : s.Nonempty\ng : ι → α\n⊢ f (s.inf' hs g) = s.inf' hs (⇑f ∘ g)",
"usedConstants": [
"Finset.inf'",
"F... | refine hs.cons_induction ?_ ?_ <;> intros | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 1043,
"column": 30
} | {
"line": 1043,
"column": 52
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\nι : Type u_5\ninst✝³ : LinearOrder α\ns : Finset ι\nf : ι → α\ninst✝² : OrderBot α\ninst✝¹ : SemilatticeSup β\ninst✝ : OrderBot β\ng : α → β\nmono_g : Monotone g\nH : s.Nonempty\n⊢ g (s.sup' H f) = s.sup (g ∘ f)",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemil... | ← Finset.sup'_eq_sup H | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Set.Finite.Lattice | {
"line": 164,
"column": 38
} | {
"line": 164,
"column": 71
} | [
{
"pp": "α : Type u\nι : Type u_1\ns : ι → Set α\nt : Set ι\nht : t.Finite\nhs : ∀ i ∈ t, (s i).Finite\nhe : ∀ i ∉ t, s i = ∅\nthis : ⋃ i, s i ⊆ ⋃ i ∈ t, s i\n⊢ (⋃ i, s i).Finite",
"usedConstants": [
"Membership.mem",
"Set.Finite.subset",
"Set.Finite.biUnion",
"Set.instMembership",
... | exact (ht.biUnion hs).subset this | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Set.Finite.Lattice | {
"line": 164,
"column": 38
} | {
"line": 164,
"column": 71
} | [
{
"pp": "α : Type u\nι : Type u_1\ns : ι → Set α\nt : Set ι\nht : t.Finite\nhs : ∀ i ∈ t, (s i).Finite\nhe : ∀ i ∉ t, s i = ∅\nthis : ⋃ i, s i ⊆ ⋃ i ∈ t, s i\n⊢ (⋃ i, s i).Finite",
"usedConstants": [
"Membership.mem",
"Set.Finite.subset",
"Set.Finite.biUnion",
"Set.instMembership",
... | exact (ht.biUnion hs).subset this | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Finite.Lattice | {
"line": 164,
"column": 38
} | {
"line": 164,
"column": 71
} | [
{
"pp": "α : Type u\nι : Type u_1\ns : ι → Set α\nt : Set ι\nht : t.Finite\nhs : ∀ i ∈ t, (s i).Finite\nhe : ∀ i ∉ t, s i = ∅\nthis : ⋃ i, s i ⊆ ⋃ i ∈ t, s i\n⊢ (⋃ i, s i).Finite",
"usedConstants": [
"Membership.mem",
"Set.Finite.subset",
"Set.Finite.biUnion",
"Set.instMembership",
... | exact (ht.biUnion hs).subset this | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.Finite.Lattice | {
"line": 243,
"column": 6
} | {
"line": 243,
"column": 20
} | [
{
"pp": "α : Type u\ns : Set α\nhs : s.Finite\nι : Type u_1\nt : ι → Set α\nh : s ⊆ ⋃ i, t i\nthis : Finite ↑s\nf : ↑s → ι\nhf : ∀ (x : ↑s), ↑x ∈ t (f x)\nx : α\nhx : x ∈ s\n⊢ x ∈ ⋃ i ∈ range f, t i",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Set.biUnion_range",
"Membership.mem",
... | biUnion_range, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Antisymmetrization | {
"line": 463,
"column": 17
} | {
"line": 463,
"column": 32
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\na b c d : α\ninst✝¹ : Preorder α\ninst✝ : Preorder β\n⊢ LeftInverse (uncurry (Quotient.lift₂ (fun a b ↦ ⟦(a, b)⟧) ⋯)) (Quotient.lift (fun ab ↦ (⟦ab.1⟧, ⟦ab.2⟧)) ⋯)",
"usedConstants": [
"AntisymmRel.setoid",
"Prod.instLE_mathlib",
"Quot.ind",
"Preo... | rintro ⟨_⟩; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Antisymmetrization | {
"line": 463,
"column": 17
} | {
"line": 463,
"column": 32
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\na b c d : α\ninst✝¹ : Preorder α\ninst✝ : Preorder β\n⊢ LeftInverse (uncurry (Quotient.lift₂ (fun a b ↦ ⟦(a, b)⟧) ⋯)) (Quotient.lift (fun ab ↦ (⟦ab.1⟧, ⟦ab.2⟧)) ⋯)",
"usedConstants": [
"AntisymmRel.setoid",
"Prod.instLE_mathlib",
"Quot.ind",
"Preo... | rintro ⟨_⟩; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.ConditionallyCompleteLattice.Indexed | {
"line": 393,
"column": 8
} | {
"line": 393,
"column": 59
} | [
{
"pp": "case pos.a.a\nα : Type u_1\nι : Sort u_4\ninst✝ : ConditionallyCompleteLinearOrder α\np : ι → Prop\nf : Subtype p → α\nhp : ¬∀ (i : ι), p i\ni₀ : ι\nhi₀ : ¬p i₀\nthis : Nonempty ι\nH : BddAbove (range f)\nB : BddAbove (range fun i ↦ if h : p i then f ⟨i, h⟩ else sSup ∅)\n⊢ iSup f ≤ ⨆ i, if h : p i then... | rcases isEmpty_or_nonempty (Subtype p) with hp | hp | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.Finset.Sigma | {
"line": 167,
"column": 4
} | {
"line": 167,
"column": 15
} | [
{
"pp": "case inr\nι : Type u_1\nα : ι → Type u_2\nβ : ι → Type u_3\nγ : ι → Type u_4\ninst✝ : DecidableEq ι\nf : ⦃i : ι⦄ → α i → β i → Finset (γ i)\nx : Sigma γ\na : α x.1\nb : β x.1\nh : x.1 ≠ x.1\nh✝ : x.snd ∈ f (⋯ ▸ ⟨x.1, a⟩.snd) (⋯ ▸ ⟨x.1, b⟩.snd)\n⊢ False",
"usedConstants": [
"rfl"
]
}
] | exact h rfl | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.Cover | {
"line": 619,
"column": 2
} | {
"line": 619,
"column": 33
} | [
{
"pp": "ι : Type u_3\nα : ι → Type u_4\ninst✝ : (i : ι) → Preorder (α i)\na b : (i : ι) → α i\nh : (a ≤ b ∧ ∃ i, a i < b i) ∧ ∀ ⦃c : (i : ι) → α i⦄, a ≤ c → ∀ (x : ι), a x < c x → c ≤ b → ∀ (x : ι), ¬c x < b x\n⊢ ∃ i, ∀ (j : ι), j ≠ i → AntisymmRel (fun x1 x2 ↦ x1 ≤ x2) (a j) (b j)",
"usedConstants": []
... | obtain ⟨⟨hab, ⟨i, hi⟩⟩, h⟩ := h | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Order.Cover | {
"line": 622,
"column": 2
} | {
"line": 622,
"column": 71
} | [
{
"pp": "ι : Type u_3\nα : ι → Type u_4\ninst✝ : (i : ι) → Preorder (α i)\na b : (i : ι) → α i\nh : ∀ ⦃c : (i : ι) → α i⦄, a ≤ c → ∀ (x : ι), a x < c x → c ≤ b → ∀ (x : ι), ¬c x < b x\nhab : a ≤ b\ni : ι\nhi : a i < b i\nj : ι\nhj : j ≠ i\nc : (i : ι) → α i := Function.update a i (b i)\n⊢ AntisymmRel (fun x1 x2... | have h₁ : c ≤ b := by simpa [update_le_iff, c] using fun k hk ↦ hab k | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Order.Interval.Finset.Defs | {
"line": 640,
"column": 26
} | {
"line": 640,
"column": 70
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝⁴ : Preorder α\ninst✝³ : Preorder β\ninst✝² : Fintype α\ninst✝¹ : DecidableLT α\ninst✝ : DecidableLE α\na b x : α\n⊢ x ∈ (Set.Ioo a b).toFinset ↔ a < x ∧ x < b",
"usedConstants": [
"Set.decidableMemIoo",
"Preorder.toLT",
"_private.Mathlib.Order.Int... | by simp only [Set.mem_toFinset, Set.mem_Ioo] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Interval.Multiset | {
"line": 230,
"column": 56
} | {
"line": 230,
"column": 72
} | [
{
"pp": "α : Type u_1\ninst✝¹ : PartialOrder α\ninst✝ : LocallyFiniteOrder α\na : α\n⊢ (Finset.Icc a a).val = {a}",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"PartialOrder.toPreorder",
"Multiset",
"id",
"Finset.Icc",
"Finset.val",
"Multiset.inst... | Finset.Icc_self, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Interval.Finset.Defs | {
"line": 657,
"column": 4
} | {
"line": 659,
"column": 47
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Preorder α\ninst✝ : Preorder β\nh₀_finset_Icc h₀_finset_Ico h₀_finset_Ioc h₀_finset_Ioo : α → α → Finset α\nh₀_finset_mem_Icc : ∀ (a b x : α), x ∈ h₀_finset_Icc a b ↔ a ≤ x ∧ x ≤ b\nh₀_finset_mem_Ico : ∀ (a b x : α), x ∈ h₀_finset_Ico a b ↔ a ≤ x ∧ x < b\nh₀_finset_... | have hIoo : h₀_finset_Ioo = h₁_finset_Ioo := by
ext a b x
rw [h₀_finset_mem_Ioo, h₁_finset_mem_Ioo] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Order.Interval.Finset.Nat | {
"line": 157,
"column": 4
} | {
"line": 157,
"column": 69
} | [
{
"pp": "case succ\na n : ℕ\nih : Set.InjOn (fun x ↦ x % a) ↑(Ico n (n + a))\nk l : ℕ\nhkl : k % a = l % a\nha : 0 < a\nhk : k ≠ n ∧ (k = n + a ∨ k ∈ Ico n (n + a))\nhl : l ≠ n ∧ (l = n + a ∨ l ∈ Ico n (n + a))\n⊢ k = l",
"usedConstants": []
}
] | rcases hk with ⟨hkn, rfl | hk⟩ <;> rcases hl with ⟨hln, rfl | hl⟩ | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Order.OrderIsoNat | {
"line": 242,
"column": 4
} | {
"line": 242,
"column": 73
} | [
{
"pp": "case inr\nα : Type u_1\ninst✝¹ : PartialOrder α\ninst✝ : WellFoundedGT α\na : ℕ →o α\nm : ℕ\nhm : monotonicSequenceLimitIndex a < m\nh : ∃ n, ∀ (m : ℕ), n ≤ m → a n = a m\n⊢ a m ≤ monotonicSequenceLimit a",
"usedConstants": [
"Eq.ge",
"PartialOrder.toPreorder",
"setOf",
"Nat... | exact (Nat.sInf_mem (s := {n | ∀ m, n ≤ m → a n = a m}) h m hm.le).ge | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.WellQuasiOrder | {
"line": 81,
"column": 2
} | {
"line": 81,
"column": 60
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nr : α → α → Prop\ns : β → β → Prop\ninst✝ : IsPreorder α r\nhr : WellQuasiOrdered r\nhs : WellQuasiOrdered s\nf : ℕ → α × β\n⊢ ∃ m n, m < n ∧ (fun a b ↦ r a.1 b.1 ∧ s a.2 b.2) (f m) (f n)",
"usedConstants": [
"Function.comp",
"Prod.fst",
"WellQuasiOrder... | obtain ⟨g, h₁⟩ := hr.exists_monotone_subseq (Prod.fst ∘ f) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Algebra.Group.Submonoid.Pointwise | {
"line": 102,
"column": 54
} | {
"line": 102,
"column": 64
} | [
{
"pp": "M : Type u_3\ninst✝ : Monoid M\nH K : Submonoid M\n⊢ H ⊔ closure ↑K ≤ H ⊔ K",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Monoid.toMulOneClass",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"CompleteLattice.toConditionallyCompleteLa... | closure_eq | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Submonoid.Pointwise | {
"line": 168,
"column": 8
} | {
"line": 168,
"column": 19
} | [
{
"pp": "case a\nG : Type u_2\ninst✝ : Group G\ns : Set G\n⊢ closure s⁻¹ ≤ (closure s)⁻¹",
"usedConstants": [
"Eq.mpr",
"Submonoid.inv",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Group.toD... | closure_le, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Submonoid.Pointwise | {
"line": 170,
"column": 16
} | {
"line": 170,
"column": 27
} | [
{
"pp": "case a\nG : Type u_2\ninst✝ : Group G\ns : Set G\n⊢ closure s ≤ (closure s⁻¹)⁻¹",
"usedConstants": [
"Eq.mpr",
"Submonoid.inv",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Group.toD... | closure_le, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Interval.Finset.Basic | {
"line": 129,
"column": 46
} | {
"line": 129,
"column": 86
} | [
{
"pp": "α : Type u_2\na b : α\ninst✝¹ : Preorder α\ninst✝ : LocallyFiniteOrder α\n⊢ a ∈ Icc a b ↔ a ≤ b",
"usedConstants": [
"congrArg",
"Finset",
"Preorder.toLE",
"Membership.mem",
"_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.left_mem_Icc._simp_1_1",
"LE.le",
... | by simp only [mem_Icc, true_and, le_rfl] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Interval.Finset.Basic | {
"line": 135,
"column": 47
} | {
"line": 135,
"column": 87
} | [
{
"pp": "α : Type u_2\na b : α\ninst✝¹ : Preorder α\ninst✝ : LocallyFiniteOrder α\n⊢ b ∈ Ioc a b ↔ a < b",
"usedConstants": [
"Preorder.toLT",
"_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.right_mem_Ioc._simp_1_1",
"and_true",
"congrArg",
"Finset",
"Preorder.toLE... | by simp only [mem_Ioc, and_true, le_rfl] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.WellFoundedSet | {
"line": 106,
"column": 4
} | {
"line": 107,
"column": 19
} | [
{
"pp": "case refine_1\nα : Type u_2\nβ : Type u_3\nr : α → α → Prop\nf : β → α\nf' : β → ↑(range f) := fun c ↦ ⟨f c, ⋯⟩\nh : WellFounded (r on f)\nc : β\n⊢ ∀ {a : β} {b : ↑(range f)}, Subrel r (fun x ↦ x ∈ range f) b (f' a) → ∃ c, f' c = b",
"usedConstants": [
"Subtype.casesOn",
"Membership.mem... | rintro _ ⟨_, c', rfl⟩ -
exact ⟨c', rfl⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.WellFoundedSet | {
"line": 106,
"column": 4
} | {
"line": 107,
"column": 19
} | [
{
"pp": "case refine_1\nα : Type u_2\nβ : Type u_3\nr : α → α → Prop\nf : β → α\nf' : β → ↑(range f) := fun c ↦ ⟨f c, ⋯⟩\nh : WellFounded (r on f)\nc : β\n⊢ ∀ {a : β} {b : ↑(range f)}, Subrel r (fun x ↦ x ∈ range f) b (f' a) → ∃ c, f' c = b",
"usedConstants": [
"Subtype.casesOn",
"Membership.mem... | rintro _ ⟨_, c', rfl⟩ -
exact ⟨c', rfl⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.WellFoundedSet | {
"line": 303,
"column": 2
} | {
"line": 303,
"column": 47
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\nr : α → α → Prop\nr' : β → β → Prop\nf : α → β\ns : Set α\nhs : ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ s) → ∃ m n, m < n ∧ r (f m) (f n)\nhf : ∀ a₁ ∈ s, ∀ a₂ ∈ s, r a₁ a₂ → r' (f a₁) (f a₂)\ng : ℕ → α\nhgs : ∀ (n : ℕ), g n ∈ s\nheq : ∀ (n : ℕ), f (g n) = (f ∘ g) n\nm n : ℕ\nhlt : ... | exact ⟨m, n, hlt, hf _ (hgs m) _ (hgs n) hmn⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.Interval.Finset.Basic | {
"line": 584,
"column": 70
} | {
"line": 585,
"column": 99
} | [
{
"pp": "α : Type u_2\ninst✝² : PartialOrder α\ninst✝¹ : LocallyFiniteOrder α\na b : α\ninst✝ : DecidableEq α\nh : a ≤ b\n⊢ insert a (Ioc a b) = Icc a b",
"usedConstants": [
"Eq.mpr",
"Set.Ioc",
"Set.insert_eq",
"congrArg",
"Finset",
"PartialOrder.toPreorder",
"Fins... | by
rw [← coe_inj, coe_insert, coe_Ioc, coe_Icc, Set.insert_eq, Set.union_comm, Set.Ioc_union_left h] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Interval.Finset.Basic | {
"line": 624,
"column": 32
} | {
"line": 624,
"column": 49
} | [
{
"pp": "α : Type u_2\ninst✝¹ : PartialOrder α\ninst✝ : LocallyFiniteOrder α\na b : α\nh : a ≤ b\n⊢ Icc a b = insert a (Ioc a b)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"PartialOrder.toPreorder",
"Classical.propDecidable",
"id",
"Insert.insert",
"... | Ioc_insert_left h | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Subgroup.Center | {
"line": 86,
"column": 6
} | {
"line": 89,
"column": 15
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nh : center G = ⊤\n⊢ ∀ (a b : G), a * b = b * a",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Group",
"Subgroup.mem_center_iff",
"Membership.mem",
"Eq.mp",
"MulOne.toMul",
"DivInvMonoid.toMo... | rw [eq_top_iff'] at h
intro x y
apply Subgroup.mem_center_iff.mp _ x
exact h y | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Subgroup.Center | {
"line": 86,
"column": 6
} | {
"line": 89,
"column": 15
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nh : center G = ⊤\n⊢ ∀ (a b : G), a * b = b * a",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Group",
"Subgroup.mem_center_iff",
"Membership.mem",
"Eq.mp",
"MulOne.toMul",
"DivInvMonoid.toMo... | rw [eq_top_iff'] at h
intro x y
apply Subgroup.mem_center_iff.mp _ x
exact h y | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.WellFoundedSet | {
"line": 879,
"column": 4
} | {
"line": 880,
"column": 14
} | [
{
"pp": "case h.left\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 : ℕ ↪o ℕ... | · by_contra hx
simp_all | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Group.Subgroup.Pointwise | {
"line": 239,
"column": 54
} | {
"line": 239,
"column": 64
} | [
{
"pp": "G : Type u_2\ninst✝ : Group G\nH K : Subgroup G\n⊢ H ⊔ closure ↑K ≤ H ⊔ K",
"usedConstants": [
"Subgroup.closure_eq",
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Subgroup.closure",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"CompleteLattice.to... | closure_eq | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Subgroup.Pointwise | {
"line": 304,
"column": 2
} | {
"line": 304,
"column": 35
} | [
{
"pp": "case h.mpr\nG : Type u_2\ninst✝ : Group G\nA B C : Subgroup G\nh : A ≤ C\nx✝ : G\n⊢ (∃ x ∈ ↑A, ∃ y ∈ ↑B, x * y = x✝) ∧ x✝ ∈ ↑C → ∃ x ∈ ↑A, ∃ y, (y ∈ ↑B ∧ y ∈ ↑C) ∧ x * y = x✝",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"Membership.mem",
"Exists",
"MulOne.... | rintro ⟨⟨y, hy, z, hz, rfl⟩, hyz⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.GroupTheory.FreeGroup.Basic | {
"line": 106,
"column": 42
} | {
"line": 106,
"column": 85
} | [
{
"pp": "α : Type u\nL1 L2 : List (α × Bool)\nx : α\nb : Bool\n⊢ (L1 ++ L2).length + 2 = (L1 ++ (x, b) :: (x, !b) :: L2).length",
"usedConstants": [
"Eq.mpr",
"Bool.not",
"congrArg",
"List.length_append",
"id",
"Prod.mk",
"instOfNatNat",
"List.cons",
"in... | rw [List.length_append, List.length_append] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Coset.Defs | {
"line": 226,
"column": 2
} | {
"line": 227,
"column": 18
} | [
{
"pp": "case h\nα : Type u_1\ninst✝ : Group α\nN : Subgroup α\ns : Set α\nx : α\n⊢ x ∈ mk ⁻¹' (mk '' s) ↔ x ∈ ⋃ x, (fun x_1 ↦ x_1 * ↑x) ⁻¹' s",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Iff.of_eq",
"Monoid.toMulOneClass",
"congrArg",
... | simp only [QuotientGroup.eq, SetLike.exists, exists_prop, Set.mem_preimage, Set.mem_iUnion,
Set.mem_image] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.BigOperators.Group.Finset.Basic | {
"line": 141,
"column": 2
} | {
"line": 141,
"column": 59
} | [
{
"pp": "ι : Type u_1\nM : Type u_4\ns₁ s₂ : Finset ι\ninst✝¹ : CommMonoid M\nf : ι → M\ninst✝ : DecidableEq ι\nh : Disjoint s₁ s₂\n⊢ ∏ x ∈ s₁ ∪ s₂, f x = (∏ x ∈ s₁, f x) * ∏ x ∈ s₂, f x",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Finset.instUnion",
"Monoid.toMulOneClass",
"co... | rw [← prod_union_inter, disjoint_iff_inter_eq_empty.mp h] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.BigOperators.Group.Finset.Basic | {
"line": 504,
"column": 4
} | {
"line": 508,
"column": 44
} | [] | ∏ x ∈ s, f x = ∏ x ∈ s with f x ≠ 1, f x := by rw [prod_filter_ne_one]
_ = ∏ x ∈ t with g x ≠ 1, g x :=
prod_bij (fun a ha => i a (mem_filter.mp ha).1 <| by simpa using (mem_filter.mp ha).2)
?_ ?_ ?_ ?_
_ = ∏ x ∈ t, g x := prod_filter_ne_one _ | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcSteps |
Mathlib.Algebra.BigOperators.Group.Finset.Basic | {
"line": 658,
"column": 4
} | {
"line": 658,
"column": 57
} | [
{
"pp": "case succ\nM : Type u_4\ninst✝ : CommMonoid M\nf : ℕ → M\nn : ℕ\nih : ∏ r ∈ range (n + 1), f (n - r) = ∏ k ∈ range (n + 1), f k\n⊢ ∏ r ∈ range (n + 1 + 1), f (n + 1 - r) = ∏ k ∈ range (n + 1 + 1), f k",
"usedConstants": [
"Eq.mpr",
"Finset.prod_range_succ'",
"HMul.hMul",
"Mo... | rw [prod_range_succ', prod_range_succ _ (Nat.succ n)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.BigOperators.Group.Finset.Basic | {
"line": 675,
"column": 8
} | {
"line": 675,
"column": 26
} | [
{
"pp": "ι : Type u_1\nM : Type u_4\ns✝ : Finset ι\ninst✝ : CommMonoid M\nf : ι → M\ns : Finset ι\nih :\n ∀ t ⊂ s,\n ∀ (g : (a : ι) → a ∈ t → ι),\n (∀ (a : ι) (ha : a ∈ t), f a * f (g a ha) = 1) →\n (∀ (a : ι) (ha : a ∈ t), f a ≠ 1 → g a ha ≠ a) →\n ∀ (g_mem : ∀ (a : ι) (ha : a ∈ t), g ... | ← prod_sdiff this, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Finiteness | {
"line": 478,
"column": 4
} | {
"line": 478,
"column": 35
} | [
{
"pp": "case refine_2\nG : Type u_3\ninst✝ : Group G\nS : Set G\nhfin : Finite ↑S\nφ : FreeGroup ↑S →* G\nhφ : Function.Surjective ⇑φ\n⊢ FG G",
"usedConstants": [
"Group.fg_of_surjective",
"Set.Elem",
"instFGFreeGroupOfFinite",
"FreeGroup",
"FreeGroup.instGroup"
]
}
] | exact Group.fg_of_surjective hφ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.GroupTheory.Finiteness | {
"line": 493,
"column": 4
} | {
"line": 493,
"column": 35
} | [
{
"pp": "case mpr\nG : Type u_3\ninst✝ : Group G\nα : Type\nw✝ : Finite α\nφ : FreeGroup α →* G\nhφ : Function.Surjective ⇑φ\n⊢ FG G",
"usedConstants": [
"Group.fg_of_surjective",
"instFGFreeGroupOfFinite",
"FreeGroup",
"FreeGroup.instGroup"
]
}
] | exact Group.fg_of_surjective hφ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.GroupTheory.Commutator.Basic | {
"line": 406,
"column": 2
} | {
"line": 406,
"column": 56
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Group G\nN : Subgroup G\ninst✝ : N.Normal\nH : Subgroup G\nhHN : N ⊔ H = ⊤\nhH : IsMulCommutative ↥H\nφ : ↥H →ₙ* G ⧸ N := ↑((QuotientGroup.mk' N).comp H.subtype)\n⊢ ((QuotientGroup.mk' N).comp H.subtype).range = ⊤",
"usedConstants": [
"Eq.mpr",
"MonoidHom.range",
... | simp only [MonoidHom.range_eq_map, ← Subgroup.map_map] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.BigOperators.Group.Finset.Basic | {
"line": 1032,
"column": 4
} | {
"line": 1036,
"column": 14
} | [
{
"pp": "M : Type u_4\nι : Type u_7\ninst✝² : Fintype ι\ninst✝¹ : CommMonoid M\np : ι → Prop\nf : ι → M\ninst✝ : DecidablePred p\n⊢ (∏ i, f ↑i) * ∏ i, f ↑i = ∏ i, f i",
"usedConstants": [
"Eq.mpr",
"instDecidableNot",
"Finset.mem_filter._simp_1",
"HMul.hMul",
"Finset.univ",
... | let s := { x | p x }.toFinset
rw [← Finset.prod_subtype s, ← Finset.prod_subtype sᶜ]
· exact Finset.prod_mul_prod_compl _ _
· simp [s]
· simp [s] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.Finset.Basic | {
"line": 1032,
"column": 4
} | {
"line": 1036,
"column": 14
} | [
{
"pp": "M : Type u_4\nι : Type u_7\ninst✝² : Fintype ι\ninst✝¹ : CommMonoid M\np : ι → Prop\nf : ι → M\ninst✝ : DecidablePred p\n⊢ (∏ i, f ↑i) * ∏ i, f ↑i = ∏ i, f i",
"usedConstants": [
"Eq.mpr",
"instDecidableNot",
"Finset.mem_filter._simp_1",
"HMul.hMul",
"Finset.univ",
... | let s := { x | p x }.toFinset
rw [← Finset.prod_subtype s, ← Finset.prod_subtype sᶜ]
· exact Finset.prod_mul_prod_compl _ _
· simp [s]
· simp [s] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Group.Finset.Basic | {
"line": 1084,
"column": 6
} | {
"line": 1084,
"column": 30
} | [
{
"pp": "ι : Type u_1\ninst✝ : DecidableEq ι\ns : Finset ι\nm : Multiset ι\nhms : ∀ a ∈ m, a ∈ s\n⊢ ∑ a ∈ s, count a m = m.card",
"usedConstants": [
"Multiset.toFinset",
"Eq.mpr",
"Multiset.toFinset_sum_count_eq",
"congrArg",
"Multiset.count",
"id",
"Nat",
"Na... | ← toFinset_sum_count_eq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 447,
"column": 42
} | {
"line": 447,
"column": 50
} | [
{
"pp": "case of.add\nα : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\ninst✝ : Semigroup α\nx : FreeAbelianGroup α\nL3 : α\ny₁ y₂ : FreeAbelianGroup α\nih₁ : x * y₁ * of L3 = x * (y₁ * of L3)\nih₂ : x * y₂ * of L3 = x * (y₂ * of L3)\n⊢ x * (y₁ + y₂) * of L3 = x * (y₁ * of L3 + y₂ * of L3)",
"usedConstants"... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 447,
"column": 51
} | {
"line": 447,
"column": 59
} | [
{
"pp": "case of.add\nα : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\ninst✝ : Semigroup α\nx : FreeAbelianGroup α\nL3 : α\ny₁ y₂ : FreeAbelianGroup α\nih₁ : x * y₁ * of L3 = x * (y₁ * of L3)\nih₂ : x * y₂ * of L3 = x * (y₂ * of L3)\n⊢ (x * y₁ + x * y₂) * of L3 = x * (y₁ * of L3 + y₂ * of L3)",
"usedConsta... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 449,
"column": 31
} | {
"line": 449,
"column": 39
} | [
{
"pp": "case add\nα : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\ninst✝ : Semigroup α\nx y z₁ z₂ : FreeAbelianGroup α\nih₁ : x * y * z₁ = x * (y * z₁)\nih₂ : x * y * z₂ = x * (y * z₂)\n⊢ x * y * (z₁ + z₂) = x * (y * (z₁ + z₂))",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 449,
"column": 40
} | {
"line": 449,
"column": 48
} | [
{
"pp": "case add\nα : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\ninst✝ : Semigroup α\nx y z₁ z₂ : FreeAbelianGroup α\nih₁ : x * y * z₁ = x * (y * z₁)\nih₂ : x * y * z₂ = x * (y * z₂)\n⊢ x * y * z₁ + x * y * z₂ = x * (y * (z₁ + z₂))",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 449,
"column": 49
} | {
"line": 449,
"column": 57
} | [
{
"pp": "case add\nα : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\ninst✝ : Semigroup α\nx y z₁ z₂ : FreeAbelianGroup α\nih₁ : x * y * z₁ = x * (y * z₁)\nih₂ : x * y * z₂ = x * (y * z₂)\n⊢ x * y * z₁ + x * y * z₂ = x * (y * z₁ + y * z₂)",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",... | mul_add, | 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.