module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.Algebra.Order.Module.Defs | {
"line": 1022,
"column": 44
} | {
"line": 1022,
"column": 58
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\na : α\nb₁ b₂ : β\ninst✝⁷ : Ring α\ninst✝⁶ : PartialOrder α\ninst✝⁵ : IsOrderedRing α\ninst✝⁴ : AddCommGroup β\ninst✝³ : PartialOrder β\ninst✝² : IsOrderedAddMonoid β\ninst✝¹ : Module α β\ninst✝ : PosSMulStrictMono α β\nhb : b₁ < b₂\nha : a < 0\n⊢ -(-a • b₂) < -(-a • b₁)",
... | neg_lt_neg_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Module.Defs | {
"line": 1041,
"column": 44
} | {
"line": 1041,
"column": 58
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\na : α\nb₁ b₂ : β\ninst✝⁷ : Ring α\ninst✝⁶ : PartialOrder α\ninst✝⁵ : IsOrderedRing α\ninst✝⁴ : AddCommGroup β\ninst✝³ : PartialOrder β\ninst✝² : IsOrderedAddMonoid β\ninst✝¹ : Module α β\ninst✝ : PosSMulReflectLT α β\nh : -(-a • b₁) < -(-a • b₂)\nha : a ≤ 0\n⊢ b₂ < b₁",
... | neg_lt_neg_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Module.Defs | {
"line": 1057,
"column": 44
} | {
"line": 1057,
"column": 58
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\na : α\nb₁ b₂ : β\ninst✝⁸ : Ring α\ninst✝⁷ : PartialOrder α\ninst✝⁶ : IsOrderedRing α\ninst✝⁵ : AddCommGroup β\ninst✝⁴ : PartialOrder β\ninst✝³ : IsOrderedAddMonoid β\ninst✝² : Module α β\ninst✝¹ : PosSMulStrictMono α β\ninst✝ : PosSMulReflectLT α β\nha : a < 0\n⊢ -(-a • b₁) ... | neg_lt_neg_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Univ | {
"line": 86,
"column": 12
} | {
"line": 86,
"column": 24
} | [
{
"pp": "case mpr.type.refine_2\nb✝ : Ordinal.{max (u + 1) v}\nβ : Type (max (u + 1) v)\ns : β → β → Prop\ninst✝¹ : IsWellOrder β s\nh✝ : lift.{max (u + 1) v, max (u + 1) v} (type s) < lift.{max (u + 1) v, u + 1} (type fun x1 x2 ↦ x1 < x2)\nf : s ↪r fun x1 x2 ↦ x1 < x2\nα : Type u\nr : α → α → Prop\ninst✝ : IsW... | typein_enum, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Univ | {
"line": 175,
"column": 4
} | {
"line": 178,
"column": 48
} | [
{
"pp": "c : Cardinal.{max (u + 1) v}\nh : c < univ.{u, v}\n⊢ ∃ c', c = lift.{max (u + 1) v, u} c'",
"usedConstants": [
"Preorder.toLT",
"Cardinal",
"Cardinal.lift_lift",
"congrArg",
"Cardinal.univ",
"_private.Mathlib.SetTheory.Ordinal.Univ.0.Cardinal.lt_univ'.match_1_3",... | let ⟨a, h', e⟩ := lt_lift_iff.1 h
rw [mk_ordinal] at h'
rcases lt_univ.{u}.1 h' with ⟨c', rfl⟩
exact ⟨c', by simp only [e.symm, lift_lift]⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Univ | {
"line": 175,
"column": 4
} | {
"line": 178,
"column": 48
} | [
{
"pp": "c : Cardinal.{max (u + 1) v}\nh : c < univ.{u, v}\n⊢ ∃ c', c = lift.{max (u + 1) v, u} c'",
"usedConstants": [
"Preorder.toLT",
"Cardinal",
"Cardinal.lift_lift",
"congrArg",
"Cardinal.univ",
"_private.Mathlib.SetTheory.Ordinal.Univ.0.Cardinal.lt_univ'.match_1_3",... | let ⟨a, h', e⟩ := lt_lift_iff.1 h
rw [mk_ordinal] at h'
rcases lt_univ.{u}.1 h' with ⟨c', rfl⟩
exact ⟨c', by simp only [e.symm, lift_lift]⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Family | {
"line": 315,
"column": 2
} | {
"line": 315,
"column": 41
} | [
{
"pp": "ι : Type u\nf : ι → Ordinal.{max u v}\n⊢ Cardinal.lift.{(max u v) + 1, max u v} (sInf (range f)ᶜ).card ≤ Cardinal.lift.{max v (u + 1) (v + 1), u} #ι",
"usedConstants": [
"Cardinal",
"Compl.compl",
"PartialOrder.toPreorder",
"Cardinal.lift",
"Cardinal.mk",
"Set.El... | apply (lift_card_sInf_compl_le _).trans | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.SetTheory.Ordinal.Family | {
"line": 464,
"column": 4
} | {
"line": 465,
"column": 9
} | [
{
"pp": "f : Ordinal.{max u_3 u_4} → Ordinal.{max u_4 u_5}\nH : IsNormal f\no : Ordinal.{u_4}\nα : Type u_4\nr : α → α → Prop\nx✝ : IsWellOrder α r\ng : (a : Ordinal.{u_4}) → a < type r → Ordinal.{max u_4 u_3}\nh : type r ≠ 0\nthis : Nonempty α\n⊢ f ((type r).bsup g) = (type r).bsup fun a h ↦ f (g a h)",
"u... | rw [← iSup'_eq_bsup r, Order.IsNormal.map_iSup H bddAbove_of_small, ← iSup'_eq_bsup r] <;>
rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.SetTheory.Ordinal.Basic | {
"line": 728,
"column": 11
} | {
"line": 728,
"column": 27
} | [
{
"pp": "a b : Ordinal.{v}\n⊢ lift.{u, v} a = lift.{u, v} b ↔ a = b",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.SetTheory.Ordinal.Basic.0.Ordinal.lift_inj._simp_1_1",
"Ordinal.partialOrder",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Ordinal.lift"... | le_antisymm_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.SetTheory.Ordinal.Basic | {
"line": 728,
"column": 2
} | {
"line": 728,
"column": 36
} | [
{
"pp": "a b : Ordinal.{v}\n⊢ lift.{u, v} a = lift.{u, v} b ↔ a = b",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.SetTheory.Ordinal.Basic.0.Ordinal.lift_inj._simp_1_1",
"Ordinal.partialOrder",
"congrArg",
"Ordinal.lift_le._simp_1",
"PartialOrder.toPreorder",
"Pre... | simp_rw [le_antisymm_iff, lift_le] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.SetTheory.Ordinal.Basic | {
"line": 728,
"column": 2
} | {
"line": 728,
"column": 36
} | [
{
"pp": "a b : Ordinal.{v}\n⊢ lift.{u, v} a = lift.{u, v} b ↔ a = b",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.SetTheory.Ordinal.Basic.0.Ordinal.lift_inj._simp_1_1",
"Ordinal.partialOrder",
"congrArg",
"Ordinal.lift_le._simp_1",
"PartialOrder.toPreorder",
"Pre... | simp_rw [le_antisymm_iff, lift_le] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Basic | {
"line": 728,
"column": 2
} | {
"line": 728,
"column": 36
} | [
{
"pp": "a b : Ordinal.{v}\n⊢ lift.{u, v} a = lift.{u, v} b ↔ a = b",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.SetTheory.Ordinal.Basic.0.Ordinal.lift_inj._simp_1_1",
"Ordinal.partialOrder",
"congrArg",
"Ordinal.lift_le._simp_1",
"PartialOrder.toPreorder",
"Pre... | simp_rw [le_antisymm_iff, lift_le] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Family | {
"line": 600,
"column": 19
} | {
"line": 600,
"column": 23
} | [
{
"pp": "case refine_2\nι : Type u_3\nf : ι → Ordinal.{max u_4 u_3}\nw✝ : ι\nhf : f w✝ = iSup f\n⊢ iSup f < lsub f",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"iSup",
"PartialOrder.toPreorder",
"id",
"ConditionallyComple... | ← hf | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Family | {
"line": 833,
"column": 19
} | {
"line": 833,
"column": 23
} | [
{
"pp": "case refine_2\no : Ordinal.{u}\nf : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}\nw✝¹ : Ordinal.{u}\nw✝ : w✝¹ < o\nhf : f w✝¹ w✝ = o.bsup f\n⊢ o.bsup f < o.blsub f",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"PartialOrder.toPreo... | ← hf | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Log | {
"line": 94,
"column": 12
} | {
"line": 94,
"column": 20
} | [
{
"pp": "case zero\nn : ℕ\nhn : n ≠ 0\nb : ℕ\nhb : 1 < b\nhfuel : n < b ^ 0\n⊢ (go n b 0).fst = n / b ^ (go n b 0).snd ∧ b ^ (go n b 0).snd ≤ n ∧ n < b ^ ((go n b 0).snd + 1)",
"usedConstants": [
"instPowNat",
"False",
"instHDiv",
"eq_false",
"False.elim",
"Nat.lt_one_iff... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Nat.Log | {
"line": 94,
"column": 12
} | {
"line": 94,
"column": 20
} | [
{
"pp": "case zero\nn : ℕ\nhn : n ≠ 0\nb : ℕ\nhb : 1 < b\nhfuel : n < b ^ 0\n⊢ (go n b 0).fst = n / b ^ (go n b 0).snd ∧ b ^ (go n b 0).snd ≤ n ∧ n < b ^ ((go n b 0).snd + 1)",
"usedConstants": [
"instPowNat",
"False",
"instHDiv",
"eq_false",
"False.elim",
"Nat.lt_one_iff... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Log | {
"line": 94,
"column": 12
} | {
"line": 94,
"column": 20
} | [
{
"pp": "case zero\nn : ℕ\nhn : n ≠ 0\nb : ℕ\nhb : 1 < b\nhfuel : n < b ^ 0\n⊢ (go n b 0).fst = n / b ^ (go n b 0).snd ∧ b ^ (go n b 0).snd ≤ n ∧ n < b ^ ((go n b 0).snd + 1)",
"usedConstants": [
"instPowNat",
"False",
"instHDiv",
"eq_false",
"False.elim",
"Nat.lt_one_iff... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Log | {
"line": 105,
"column": 16
} | {
"line": 105,
"column": 24
} | [
{
"pp": "case succ.inr.isTrue\nn : ℕ\nhn : n ≠ 0\nfuel : ℕ\nih :\n ∀ {b : ℕ},\n 1 < b →\n n < b ^ fuel →\n (go n b fuel).fst = n / b ^ (go n b fuel).snd ∧ b ^ (go n b fuel).snd ≤ n ∧ n < b ^ ((go n b fuel).snd + 1)\nb : ℕ\nhb : 1 < b\nhfuel : n < b ^ (fuel + 1)\nhnb : n ≥ b\nih₁ : (go n (b ^ 2) ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Nat.Log | {
"line": 105,
"column": 16
} | {
"line": 105,
"column": 24
} | [
{
"pp": "case succ.inr.isFalse\nn : ℕ\nhn : n ≠ 0\nfuel : ℕ\nih :\n ∀ {b : ℕ},\n 1 < b →\n n < b ^ fuel →\n (go n b fuel).fst = n / b ^ (go n b fuel).snd ∧ b ^ (go n b fuel).snd ≤ n ∧ n < b ^ ((go n b fuel).snd + 1)\nb : ℕ\nhb : 1 < b\nhfuel : n < b ^ (fuel + 1)\nhnb : n ≥ b\nih₁ : (go n (b ^ 2)... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.Ordinal.Basic | {
"line": 1380,
"column": 27
} | {
"line": 1380,
"column": 39
} | [
{
"pp": "α : Type u\nr : α → α → Prop\ninst✝ : IsWellOrder α r\ns : Set α\nhfin : s.Finite\nh : sᶜ.Nonempty\n⊢ (typein r).toRelEmbedding (⋯.min sᶜ h) ≤ (typein r).toRelEmbedding ((enum r) ⟨(#↑s).ord, ⋯⟩)",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrAr... | typein_enum, | Mathlib.Tactic.evalGRewriteSeq | null |
Mathlib.Data.Nat.Log | {
"line": 202,
"column": 8
} | {
"line": 202,
"column": 24
} | [
{
"pp": "case inl\nb m n : ℕ\nh : m ≠ 0 ∨ 1 < b ∧ n ≠ 0\nhb : 1 < b\nhn : n ≠ 0\n⊢ log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)",
"usedConstants": [
"instPowNat",
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"instOfNatNat",
"LE.le",
... | le_antisymm_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Log | {
"line": 371,
"column": 12
} | {
"line": 371,
"column": 20
} | [
{
"pp": "case zero\nn : ℕ\nhn : 1 < n\nb : ℕ\nhb : 1 < b\nhfuel : n < b ^ 0\n⊢ (go n b 0).fst = b ^ ((go n b 0).snd + 1) / n ∧ b ^ (go n b 0).snd < n ∧ n ≤ b ^ ((go n b 0).snd + 1)",
"usedConstants": [
"instPowNat",
"Eq.mpr",
"False",
"instHDiv",
"and_true",
"congrArg",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Nat.Log | {
"line": 371,
"column": 12
} | {
"line": 371,
"column": 20
} | [
{
"pp": "case zero\nn : ℕ\nhn : 1 < n\nb : ℕ\nhb : 1 < b\nhfuel : n < b ^ 0\n⊢ (go n b 0).fst = b ^ ((go n b 0).snd + 1) / n ∧ b ^ (go n b 0).snd < n ∧ n ≤ b ^ ((go n b 0).snd + 1)",
"usedConstants": [
"instPowNat",
"Eq.mpr",
"False",
"instHDiv",
"and_true",
"congrArg",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Log | {
"line": 371,
"column": 12
} | {
"line": 371,
"column": 20
} | [
{
"pp": "case zero\nn : ℕ\nhn : 1 < n\nb : ℕ\nhb : 1 < b\nhfuel : n < b ^ 0\n⊢ (go n b 0).fst = b ^ ((go n b 0).snd + 1) / n ∧ b ^ (go n b 0).snd < n ∧ n ≤ b ^ ((go n b 0).snd + 1)",
"usedConstants": [
"instPowNat",
"Eq.mpr",
"False",
"instHDiv",
"and_true",
"congrArg",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 174,
"column": 4
} | {
"line": 174,
"column": 12
} | [
{
"pp": "case inl\na b c : Ordinal.{u_1}\nh₁✝ : 0 < a\nh₂ : b ≤ c\nh₁ : a = 1\n⊢ a ^ b ≤ a ^ c",
"usedConstants": [
"Ordinal.partialOrder",
"instReflLe",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Std.le_refl._simp_1",
"Ordinal.one_opow",
"LE.le"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 174,
"column": 4
} | {
"line": 174,
"column": 12
} | [
{
"pp": "case inl\na b c : Ordinal.{u_1}\nh₁✝ : 0 < a\nh₂ : b ≤ c\nh₁ : a = 1\n⊢ a ^ b ≤ a ^ c",
"usedConstants": [
"Ordinal.partialOrder",
"instReflLe",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Std.le_refl._simp_1",
"Ordinal.one_opow",
"LE.le"... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 174,
"column": 4
} | {
"line": 174,
"column": 12
} | [
{
"pp": "case inl\na b c : Ordinal.{u_1}\nh₁✝ : 0 < a\nh₂ : b ≤ c\nh₁ : a = 1\n⊢ a ^ b ≤ a ^ c",
"usedConstants": [
"Ordinal.partialOrder",
"instReflLe",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Std.le_refl._simp_1",
"Ordinal.one_opow",
"LE.le"... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 180,
"column": 23
} | {
"line": 180,
"column": 31
} | [
{
"pp": "case pos\na b c : Ordinal.{u_1}\nab : a ≤ b\nha : a = 0\nh✝ : c = 0\n⊢ a ^ c ≤ b ^ c",
"usedConstants": [
"Ordinal.partialOrder",
"instReflLe",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Std.le_refl._simp_1",
"LE.le",
"Ordinal.one",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 180,
"column": 23
} | {
"line": 180,
"column": 31
} | [
{
"pp": "case neg\na b c : Ordinal.{u_1}\nab : a ≤ b\nha : a = 0\nh✝ : ¬c = 0\n⊢ a ^ c ≤ b ^ c",
"usedConstants": [
"False",
"eq_false",
"Ordinal.partialOrder",
"congrArg",
"instIsBotZeroClass",
"zero_le._simp_1",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPr... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 246,
"column": 23
} | {
"line": 246,
"column": 31
} | [
{
"pp": "case pos\nb c : Ordinal.{u_1}\nhb : 0 < b\nthis : b ≠ 0\nh✝ : c = 0\n⊢ 0 ^ (b * c) = (0 ^ b) ^ c",
"usedConstants": [
"False",
"HMul.hMul",
"eq_false",
"MulZeroClass.toMul",
"congrArg",
"id",
"MulZeroClass.mul_zero",
"Ordinal.one",
"MonoidWithZe... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 246,
"column": 23
} | {
"line": 246,
"column": 31
} | [
{
"pp": "case neg\nb c : Ordinal.{u_1}\nhb : 0 < b\nthis : b ≠ 0\nh✝ : ¬c = 0\n⊢ 0 ^ (b * c) = (0 ^ b) ^ c",
"usedConstants": [
"False",
"Ordinal.noZeroDivisors",
"HMul.hMul",
"eq_false",
"MulZeroClass.toMul",
"congrArg",
"id",
"MonoidWithZero.toMulZeroOneClas... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 250,
"column": 51
} | {
"line": 250,
"column": 63
} | [
{
"pp": "case inr.inr.inr.add_one\na b : Ordinal.{u_1}\nhb : 0 < b\nha : a ≠ 0\nha' : 1 < a\nc : Ordinal.{u_1}\nIH : a ^ (b * c) = (a ^ b) ^ c\n⊢ (a ^ b) ^ c * a ^ b = (a ^ b) ^ (c + 1)",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"id",
"O... | opow_add_one | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.FixedPoint | {
"line": 421,
"column": 2
} | {
"line": 422,
"column": 62
} | [
{
"pp": "a b : Ordinal.{u_1}\nhba : b ≤ a * ω\n⊢ a * ω ≤ nfp (fun x ↦ a + x) b",
"usedConstants": [
"zero_le",
"Eq.mpr",
"Ordinal.instLinearOrder",
"HMul.hMul",
"Ordinal.omega0",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"congrArg",
"instIsBotZeroCla... | · rw [← nfp_add_zero]
exact nfp_monotone (isNormal_add_right a).monotone zero_le | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.SetTheory.Ordinal.Principal | {
"line": 228,
"column": 33
} | {
"line": 228,
"column": 41
} | [
{
"pp": "case refine_1.inr.inl\no : Ordinal.{u}\nho : IsPrincipal (fun x1 x2 ↦ x1 + x2) o\na : Ordinal.{u}\nhao : a < o\nho₁ : o ≤ 1\nh✝ : o = 0\n⊢ a + o = o",
"usedConstants": [
"not_lt_zero._simp_1",
"False",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"instIsB... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.Ordinal.Principal | {
"line": 228,
"column": 33
} | {
"line": 228,
"column": 41
} | [
{
"pp": "case refine_1.inr.inr\no : Ordinal.{u}\nho : IsPrincipal (fun x1 x2 ↦ x1 + x2) o\na : Ordinal.{u}\nhao : a < o\nho₁ : o ≤ 1\nh✝ : o = 1\n⊢ a + o = o",
"usedConstants": [
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"instIsBotZeroClass... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.Cardinal.Aleph | {
"line": 196,
"column": 73
} | {
"line": 197,
"column": 58
} | [
{
"pp": "x : Ordinal.{u_1}\n⊢ ω < preOmega x ↔ ω < x",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Ordinal.omega0",
"Ordinal.partialOrder",
"congrArg",
"Iff.rfl",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Eq.rec",
"id",
"Iff",
"LT... | by
conv_lhs => rw [← preOmega_omega0, preOmega_lt_preOmega] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Cardinal.Aleph | {
"line": 507,
"column": 38
} | {
"line": 508,
"column": 41
} | [
{
"pp": "⊢ succ ℵ₀ = ℵ_ 1",
"usedConstants": [
"Eq.mpr",
"Order.succ",
"Cardinal.aleph",
"Ordinal.partialOrder",
"Cardinal",
"congrArg",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Cardinal.instSuccOrder",
"AddZer... | by
rw [← aleph_zero, succ_aleph, zero_add] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Cardinal.Ordinal | {
"line": 130,
"column": 4
} | {
"line": 130,
"column": 95
} | [
{
"pp": "case add_one\na : Ordinal.{u_1}\nha : ω ≤ a\nb : Ordinal.{u_1}\nIH : (a ^ b).card ≤ max a.card b.card\n⊢ (a ^ (b + 1)).card ≤ max a.card (b + 1).card",
"usedConstants": [
"Ordinal.card_add_one",
"Eq.mpr",
"Lattice.toSemilatticeSup",
"HMul.hMul",
"Cardinal.instOne",
... | rw [opow_add_one, card_mul, card_add_one, Cardinal.mul_eq_max_of_aleph0_le_right, max_comm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | {
"line": 130,
"column": 68
} | {
"line": 131,
"column": 53
} | [
{
"pp": "o : Ordinal.{u_1}\n⊢ o.cof < ℵ₀ ↔ o.cof ≤ 1",
"usedConstants": [
"Preorder.toLT",
"Cardinal.instOne",
"Cardinal",
"congrArg",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"Eq.mp",
"DistribLattice.toLattice",
"linearOrder_toType",
... | by
simpa using Order.cof_lt_aleph0_iff (α := o.ToType) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 118,
"column": 2
} | {
"line": 118,
"column": 39
} | [
{
"pp": "a b c : Cardinal.{u_1}\nhc : ℵ₀ ≤ c\nha : a < c\nhb : b < c\n⊢ max a b * max a b < c",
"usedConstants": [
"Lattice.toSemilatticeSup",
"Cardinal",
"SemilatticeSup.toMax",
"Cardinal.aleph0",
"ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice",
"Cardin... | obtain h | h := lt_or_ge (max a b) ℵ₀ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 158,
"column": 6
} | {
"line": 158,
"column": 66
} | [
{
"pp": "case inr.inr.inr.inl\na b : Cardinal.{u_1}\nha0 : a ≠ 0\nhb0 : b ≠ 0\nha : a < ℵ₀\nhb : ℵ₀ ≤ b\n⊢ a * b ≤ max (max a b) ℵ₀",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"HMul.hMul",
"Cardinal",
"CommSemiring.toNonUnitalCommSemiring",
"congrArg",
... | rw [mul_comm, mul_eq_max_of_aleph0_le_left hb ha0, max_comm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | {
"line": 339,
"column": 8
} | {
"line": 339,
"column": 12
} | [
{
"pp": "case refine_1\no : Ordinal.{u}\nι : Type u\nf : ι → Ordinal.{u}\nhf : lsub f = o\n⊢ o.cof ≤ #ι",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Cardinal",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Cardinal.mk",
"id",
"L... | ← hf | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Cardinal.Pigeonhole | {
"line": 100,
"column": 40
} | {
"line": 100,
"column": 58
} | [
{
"pp": "β α : Type u\nf : β → α\nh : #α < #β\ninst✝ : Uncountable β\n⊢ ∃ a, ℵ₀ < #↑(f ⁻¹' {a})",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Cardinal.aleph",
"Ordinal.partialOrder",
"Cardinal",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
... | ← aleph_one_le_iff | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 310,
"column": 80
} | {
"line": 311,
"column": 32
} | [
{
"pp": "a b : Cardinal.{u_1}\n⊢ a + b = b ↔ max ℵ₀ a ≤ b ∨ a = 0",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Cardinal",
"congrArg",
"CommSemiring.toSemiring",
"Iff.rfl",
"Cardinal.commSemiring",
"SemilatticeSup.toMax",
"id",
"Cardi... | by
rw [add_comm, add_eq_left_iff] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 421,
"column": 39
} | {
"line": 421,
"column": 57
} | [
{
"pp": "ι : Type u\nf : ι → Cardinal.{v}\nc : Cardinal.{v}\n⊢ ⨆ i, f i * c = ⨆ i, c * f i",
"usedConstants": [
"HMul.hMul",
"Cardinal",
"CommSemiring.toNonUnitalCommSemiring",
"congrArg",
"iSup",
"Cardinal.commSemiring",
"Cardinal.instMul",
"CommMagma.toMul",... | simp_rw [mul_comm] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 430,
"column": 2
} | {
"line": 430,
"column": 38
} | [
{
"pp": "ι : Type u\ninst✝ : Small.{v, u} ι\nf : ι → Cardinal.{v}\nhι : ℵ₀ ≤ #ι\nh : lift.{v, u} #ι ≤ ⨆ i, lift.{u, v} (f i)\n⊢ sum f = lift.{u, v} (⨆ i, f i)",
"usedConstants": [
"Cardinal",
"LE.le.antisymm'",
"iSup",
"Cardinal.lift",
"ConditionallyCompleteLinearOrder.toCondit... | apply (lift_iSup_le_sum f).antisymm' | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 492,
"column": 4
} | {
"line": 492,
"column": 62
} | [
{
"pp": "case inr\nκ₁ κ₂ μ₁ μ₂ : Cardinal.{u_1}\nhκ : κ₁ < κ₂\nhμ : μ₁ < μ₂\nhfin : κ₂ + μ₂ < ℵ₀\n⊢ κ₁ + μ₁ < κ₂ + μ₂",
"usedConstants": [
"Preorder.toLT",
"Cardinal",
"PartialOrder.toPreorder",
"Cardinal.add_lt_aleph0_iff",
"Cardinal.aleph0",
"Cardinal.instAdd",
"i... | have hfin_ : κ₂ < ℵ₀ ∧ μ₂ < ℵ₀ := add_lt_aleph0_iff.1 hfin | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.DFinsupp.Defs | {
"line": 120,
"column": 10
} | {
"line": 120,
"column": 17
} | [
{
"pp": "ι : Type u\nγ : Type w\nβ : ι → Type v\nβ₁ : ι → Type v₁\nβ₂ : ι → Type v₂\ninst✝² : (i : ι) → Zero (β i)\ninst✝¹ : (i : ι) → Zero (β₁ i)\ninst✝ : (i : ι) → Zero (β₂ i)\nf : (i : ι) → β₁ i → β₂ i\nhf : ∀ (i : ι), f i 0 = 0\nx : Π₀ (i : ι), β₁ i\ns : { s // ∀ (i : ι), i ∈ s ∨ x.toFun i = 0 }\ni : ι\nh :... | ← hf i, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fintype.Quotient | {
"line": 119,
"column": 2
} | {
"line": 119,
"column": 61
} | [
{
"pp": "ι : Type u_1\ninst✝¹ : Fintype ι\ninst✝ : DecidableEq ι\nα : ι → Sort u_2\nS : (i : ι) → Setoid (α i)\na : (i : ι) → α i\n⊢ ((Equiv.subtypeQuotientEquivQuotientSubtype (fun l ↦ ∀ (i : ι), i ∈ l) (fun s ↦ ∀ (i : ι), i ∈ s) ⋯ ⋯)\n ⟨Finset.univ.val, ⋯⟩).liftOn\n (fun l ↦ Quotient.map (fun a ... | obtain ⟨l, hl⟩ := (Finset.univ.val : Multiset ι).exists_rep | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.DFinsupp.Defs | {
"line": 912,
"column": 2
} | {
"line": 912,
"column": 10
} | [
{
"pp": "case h\nι : Type u\nβ₁ : ι → Type v₁\nβ₂ : ι → Type v₂\ninst✝³ : DecidableEq ι\ninst✝² : (i : ι) → Zero (β₁ i)\ninst✝¹ : (i : ι) → Zero (β₂ i)\ninst✝ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)\nf : (i : ι) → β₁ i → β₂ i\nhf : ∀ (i : ι), f i 0 = 0\ng : Π₀ (i : ι), β₁ i\ni✝ : ι\n⊢ (mapRange f hf g) i✝ = ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.DFinsupp.BigOperators | {
"line": 94,
"column": 2
} | {
"line": 94,
"column": 16
} | [
{
"pp": "ι : Type u\nγ : Type w\nβ : ι → Type v\ninst✝³ : DecidableEq ι\ninst✝² : (i : ι) → Zero (β i)\ninst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)\ninst✝ : CommMonoid γ\nf : Π₀ (i : ι), β i\ng : (i : ι) → β i → γ\ns : Finset ι\nhs : f.support ⊆ s\nmap_zero : ∀ i ∈ s, g i 0 = 1\n⊢ ∀ x ∈ s, x ∉ f.support → ... | intro i hi hi' | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Data.Fin.Tuple.Reflection | {
"line": 106,
"column": 4
} | {
"line": 107,
"column": 7
} | [
{
"pp": "α : Type u_1\nP : (Fin 0 → α) → Prop\n⊢ Forall P ↔ ∀ (x : Fin 0 → α), P x",
"usedConstants": [
"Eq.mpr",
"finZeroElim",
"congrArg",
"Iff.rfl",
"FinVec.Forall",
"id",
"instOfNatNat",
"Iff",
"Nat",
"Matrix.vecEmpty",
"OfNat.ofNat",
... | simp only [Forall, Fin.forall_fin_zero_pi]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.Tuple.Reflection | {
"line": 106,
"column": 4
} | {
"line": 107,
"column": 7
} | [
{
"pp": "α : Type u_1\nP : (Fin 0 → α) → Prop\n⊢ Forall P ↔ ∀ (x : Fin 0 → α), P x",
"usedConstants": [
"Eq.mpr",
"finZeroElim",
"congrArg",
"Iff.rfl",
"FinVec.Forall",
"id",
"instOfNatNat",
"Iff",
"Nat",
"Matrix.vecEmpty",
"OfNat.ofNat",
... | simp only [Forall, Fin.forall_fin_zero_pi]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 139,
"column": 53
} | {
"line": 139,
"column": 61
} | [
{
"pp": "ι : Type u'\nR : Type u_2\nM : Type u_4\ninst✝² : Semiring R\ninst✝¹ : AddCommMonoid M\ninst✝ : Module R M\ni : ι\nm : M\nhm : (Finsupp.lsingle i) m ∈ ↑(⨆ j, ⨆ (_ : j ≠ i), (fun i ↦ (Finsupp.lsingle i).range) j)\nthis✝ : ⨆ j, ⨆ (_ : j ≠ i), (Finsupp.lsingle j).range ≤ Finsupp.supported M R {i}ᶜ\nthis :... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.Algebra.Opposite | {
"line": 47,
"column": 4
} | {
"line": 48,
"column": 50
} | [
{
"pp": "R : Type u_1\nS : Type u_2\nA : Type u_3\nB : Type u_4\ninst✝⁹ : CommSemiring R\ninst✝⁸ : CommSemiring S\ninst✝⁷ : Semiring A\ninst✝⁶ : Semiring B\ninst✝⁵ : Algebra R S\ninst✝⁴ : Algebra R A\ninst✝³ : Algebra R B\ninst✝² : Algebra S A\ninst✝¹ : SMulCommClass R S A\ninst✝ : IsScalarTower R S A\nc : R\nx... | simp only [unop_smul, RingHom.toOpposite_apply, Function.comp_apply, unop_mul,
Algebra.smul_def, Algebra.commutes, unop_op] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Algebra.Opposite | {
"line": 47,
"column": 4
} | {
"line": 48,
"column": 50
} | [
{
"pp": "R : Type u_1\nS : Type u_2\nA : Type u_3\nB : Type u_4\ninst✝⁹ : CommSemiring R\ninst✝⁸ : CommSemiring S\ninst✝⁷ : Semiring A\ninst✝⁶ : Semiring B\ninst✝⁵ : Algebra R S\ninst✝⁴ : Algebra R A\ninst✝³ : Algebra R B\ninst✝² : Algebra S A\ninst✝¹ : SMulCommClass R S A\ninst✝ : IsScalarTower R S A\nc : R\nx... | simp only [unop_smul, RingHom.toOpposite_apply, Function.comp_apply, unop_mul,
Algebra.smul_def, Algebra.commutes, unop_op] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Algebra.Opposite | {
"line": 47,
"column": 4
} | {
"line": 48,
"column": 50
} | [
{
"pp": "R : Type u_1\nS : Type u_2\nA : Type u_3\nB : Type u_4\ninst✝⁹ : CommSemiring R\ninst✝⁸ : CommSemiring S\ninst✝⁷ : Semiring A\ninst✝⁶ : Semiring B\ninst✝⁵ : Algebra R S\ninst✝⁴ : Algebra R A\ninst✝³ : Algebra R B\ninst✝² : Algebra S A\ninst✝¹ : SMulCommClass R S A\ninst✝ : IsScalarTower R S A\nc : R\nx... | simp only [unop_smul, RingHom.toOpposite_apply, Function.comp_apply, unop_mul,
Algebra.smul_def, Algebra.commutes, unop_op] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 206,
"column": 4
} | {
"line": 206,
"column": 32
} | [
{
"pp": "ι : Type u'\nR : Type u_2\nM : Type u_4\ninst✝² : Semiring R\ninst✝¹ : AddCommMonoid M\ninst✝ : Module R M\nv : ι → M\nindep : Set ι → Prop := fun s ↦ LinearIndepOn R v s\nX : Type (max 0 u') := { I // indep I }\nr : X → X → Prop := fun I J ↦ ↑I ⊆ ↑J\nc : Set X\nhc : IsChain r c\n⊢ ∀ f ∈ Finsupp.suppor... | intro f hfsupp g hgsupp hsum | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 302,
"column": 4
} | {
"line": 303,
"column": 82
} | [
{
"pp": "case refine_2\nR : Type u_2\nM : Type u_4\ninst✝⁹ : Ring R\ninst✝⁸ : AddCommGroup M\ninst✝⁷ : Module R M\nx y : M\nS : Type u_6\ninst✝⁶ : CommRing S\ninst✝⁵ : IsDomain S\ninst✝⁴ : Module S R\ninst✝³ : Module S M\ninst✝² : SMulCommClass S R M\ninst✝¹ : IsScalarTower S R M\ninst✝ : IsTorsionFree S R\nu :... | specialize h (u • s) (u • t) (by rw [smul_assoc, smul_assoc, smul_comm u s, smul_comm u t, hst])
exact ⟨(smul_eq_zero_iff_right hu).mp h.1, (smul_eq_zero_iff_right hu).mp h.2⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 302,
"column": 4
} | {
"line": 303,
"column": 82
} | [
{
"pp": "case refine_2\nR : Type u_2\nM : Type u_4\ninst✝⁹ : Ring R\ninst✝⁸ : AddCommGroup M\ninst✝⁷ : Module R M\nx y : M\nS : Type u_6\ninst✝⁶ : CommRing S\ninst✝⁵ : IsDomain S\ninst✝⁴ : Module S R\ninst✝³ : Module S M\ninst✝² : SMulCommClass S R M\ninst✝¹ : IsScalarTower S R M\ninst✝ : IsTorsionFree S R\nu :... | specialize h (u • s) (u • t) (by rw [smul_assoc, smul_assoc, smul_comm u s, smul_comm u t, hst])
exact ⟨(smul_eq_zero_iff_right hu).mp h.1, (smul_eq_zero_iff_right hu).mp h.2⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 320,
"column": 91
} | {
"line": 320,
"column": 94
} | [
{
"pp": "case left\nR : Type u_2\nM : Type u_4\ninst✝⁹ : Ring R\ninst✝⁸ : AddCommGroup M\ninst✝⁷ : Module R M\nx y : M\nS : Type u_6\ninst✝⁶ : CommRing S\ninst✝⁵ : IsDomain S\ninst✝⁴ : Module S R\ninst✝³ : Module S M\ninst✝² : SMulCommClass S R M\ninst✝¹ : IsScalarTower S R M\ninst✝ : IsTorsionFree S R\na b c d... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 326,
"column": 79
} | {
"line": 326,
"column": 82
} | [
{
"pp": "R : Type u_2\nM : Type u_4\ninst✝⁹ : Ring R\ninst✝⁸ : AddCommGroup M\ninst✝⁷ : Module R M\nx y : M\nS : Type u_6\ninst✝⁶ : CommRing S\ninst✝⁵ : IsDomain S\ninst✝⁴ : Module S R\ninst✝³ : Module S M\ninst✝² : SMulCommClass S R M\ninst✝¹ : IsScalarTower S R M\ninst✝ : IsTorsionFree S R\na b c d : S\nh : a... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 343,
"column": 51
} | {
"line": 343,
"column": 59
} | [
{
"pp": "R : Type u_2\nM : Type u_4\ninst✝¹⁰ : Ring R\ninst✝⁹ : AddCommGroup M\ninst✝⁸ : Module R M\nx y : M\nS : Type u_6\ninst✝⁷ : CommRing S\ninst✝⁶ : IsDomain S\ninst✝⁵ : Module S R\ninst✝⁴ : Module S M\ninst✝³ : SMulCommClass S R M\ninst✝² : IsScalarTower S R M\ninst✝¹ : IsTorsionFree S R\na b c d : S\nins... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.LinearAlgebra.DFinsupp | {
"line": 615,
"column": 4
} | {
"line": 615,
"column": 12
} | [
{
"pp": "case mpr\nι : Type u_1\nR : Type u_3\nN : Type u_6\ninst✝² : Ring R\ninst✝¹ : AddCommGroup N\ninst✝ : Module R N\np : ι → Submodule R N\ns : Finset ι\nv : ι → N\nhv : ∀ i ∈ s, v i ∈ p i\nhv0 : ∑ i ∈ s, v i = 0\nh : (∀ i ∈ s, v i ∈ p i ∧ 0 i ∈ p i) → ∑ i ∈ s, v i = ∑ i ∈ s, 0 i → ∀ i ∈ s, v i = 0 i\n⊢ ∀... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 371,
"column": 6
} | {
"line": 371,
"column": 9
} | [
{
"pp": "R : Type u_2\nM : Type u_4\ninst✝² : Ring R\ninst✝¹ : AddCommGroup M\ninst✝ : Module R M\nx✝ y✝ x y : M\nh : ∀ (s t : R), s • x + t • (x + y) = 0 → s = 0 ∧ t = 0\ns t : R\nh' : s • x + t • y = 0\nh₁ : s - t = 0\nh₂ : t = 0\n⊢ s = 0 ∧ t = 0",
"usedConstants": [
"AddGroupWithOne.toAddGroup",
... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 549,
"column": 4
} | {
"line": 549,
"column": 12
} | [
{
"pp": "K : Type u_3\nV : Type u\ninst✝² : DivisionRing K\ninst✝¹ : AddCommGroup V\ninst✝ : Module K V\ns : Set V\ny z : V\nhz : z ∈ span K s\nh : 0 • y + z ∉ span K s\n⊢ False",
"usedConstants": [
"Submodule",
"False",
"instHSMul",
"congrArg",
"DistribMulAction.toDistribSMul"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.Module.BigOperators | {
"line": 33,
"column": 72
} | {
"line": 36,
"column": 59
} | [
{
"pp": "R : Type u_5\nM : Type u_6\ninst✝² : Semiring R\ninst✝¹ : AddCommMonoid M\ninst✝ : Module R M\ns : Multiset R\nt : Multiset M\n⊢ s.sum • t.sum = (map (fun p ↦ p.1 • p.2) (s ×ˢ t)).sum",
"usedConstants": [
"Multiset.sum",
"instHSMul",
"Multiset.map",
"Multiset.instSProd",
... | by
induction s using Multiset.induction with
| empty => simp
| cons a s ih => simp [add_smul, ih, ← Multiset.smul_sum] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.NAry | {
"line": 185,
"column": 18
} | {
"line": 187,
"column": 34
} | [
{
"pp": "α : Type u_1\nβ : Type u_3\nγ : Type u_5\ninst✝¹ : DecidableEq γ\nf : α → β → γ\ns s' : Finset α\nt : Finset β\ninst✝ : DecidableEq α\n⊢ ↑(image₂ f (s ∩ s') t) ⊆ ↑(image₂ f s t ∩ image₂ f s' t)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"id",
"HasSubset.Subse... | by
push_cast
exact image2_inter_subset_left | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.NAry | {
"line": 391,
"column": 6
} | {
"line": 391,
"column": 19
} | [
{
"pp": "α : Type u_1\nα' : Type u_2\nβ : Type u_3\nβ' : Type u_4\nγ : Type u_5\nδ : Type u_7\ninst✝³ : DecidableEq α'\ninst✝² : DecidableEq β'\ninst✝¹ : DecidableEq γ\nf : α → β → γ\ns : Finset α\nt : Finset β\ninst✝ : DecidableEq δ\ng : γ → δ\nf' : β' → α' → δ\ng₁ : β → β'\ng₂ : α → α'\nh_antidistrib : ∀ (a :... | image₂_swap f | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | {
"line": 78,
"column": 70
} | {
"line": 78,
"column": 98
} | [
{
"pp": "case refine_1\nR : Type u_1\nA : Type u_2\ninst✝¹ : Semiring R\ninst✝ : Mul A\nf g : R[A]\na0 b0 : A\nh : UniqueMul f.support g.support a0 b0\n⊢ ∀ b ∈ f.support ×ˢ g.support, b ≠ (a0, b0) → (if b.1 * b.2 = a0 * b0 then f b.1 * g b.2 else 0) = 0",
"usedConstants": [
"Finsupp.instFunLike",
... | simp_rw [Finset.mem_product] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | {
"line": 78,
"column": 70
} | {
"line": 78,
"column": 98
} | [
{
"pp": "case refine_2\nR : Type u_1\nA : Type u_2\ninst✝¹ : Semiring R\ninst✝ : Mul A\nf g : R[A]\na0 b0 : A\nh : UniqueMul f.support g.support a0 b0\n⊢ (a0, b0) ∉ f.support ×ˢ g.support → (if (a0, b0).1 * (a0, b0).2 = a0 * b0 then f (a0, b0).1 * g (a0, b0).2 else 0) = 0",
"usedConstants": [
"Finsupp... | simp_rw [Finset.mem_product] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | {
"line": 93,
"column": 4
} | {
"line": 93,
"column": 35
} | [
{
"pp": "R : Type u_1\nA : Type u_2\ninst✝³ : Semiring R\ninst✝² : NoZeroDivisors R\ninst✝¹ : Mul A\ninst✝ : UniqueProds A\na b : R[A]\nab : a ≠ 0 ∧ b ≠ 0\nda : A\na0 : da ∈ a.support\ndb : A\nb0 : db ∈ b.support\nh : UniqueMul a.support b.support da db\n⊢ da * db ∈ (a * b).support",
"usedConstants": [
... | rw [mem_support_iff] at a0 b0 ⊢ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Multiset.Sort | {
"line": 83,
"column": 43
} | {
"line": 83,
"column": 69
} | [
{
"pp": "α : Type u_1\na : α\ns : Multiset α\nr : α → α → Prop\ninst✝³ : DecidableRel r\ninst✝² : IsTrans α r\ninst✝¹ : Std.Antisymm r\ninst✝ : Std.Total r\n⊢ a ∈ s.sort r ↔ a ∈ s",
"usedConstants": [
"Eq.mpr",
"Multiset.mem_coe",
"congrArg",
"Iff.rfl",
"Membership.mem",
... | by rw [← mem_coe, sort_eq] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.MonoidAlgebra.Defs | {
"line": 488,
"column": 6
} | {
"line": 488,
"column": 45
} | [
{
"pp": "R : Type u_1\nM : Type u_4\ninst✝¹ : Semiring R\nx : R[M]\nr : R\nm m₁ m₂ : M\ninst✝ : Mul M\nH : ∀ m' ∈ x.support, m' * m = m₁ ↔ m' = m₂\n⊢ (sum x fun m' r' ↦ if m' * m = m₁ then r' * r else 0) = sum x fun m' r' ↦ if m' = m₂ then r' * r else 0",
"usedConstants": [
"Finsupp.instFunLike",
... | dsimp [Finsupp.sum]; congr! 2; simp [*] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MonoidAlgebra.Defs | {
"line": 488,
"column": 6
} | {
"line": 488,
"column": 45
} | [
{
"pp": "R : Type u_1\nM : Type u_4\ninst✝¹ : Semiring R\nx : R[M]\nr : R\nm m₁ m₂ : M\ninst✝ : Mul M\nH : ∀ m' ∈ x.support, m' * m = m₁ ↔ m' = m₂\n⊢ (sum x fun m' r' ↦ if m' * m = m₁ then r' * r else 0) = sum x fun m' r' ↦ if m' = m₂ then r' * r else 0",
"usedConstants": [
"Finsupp.instFunLike",
... | dsimp [Finsupp.sum]; congr! 2; simp [*] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.MonoidAlgebra.Defs | {
"line": 499,
"column": 6
} | {
"line": 499,
"column": 45
} | [
{
"pp": "R : Type u_1\nM : Type u_4\ninst✝¹ : Semiring R\nx : R[M]\nr : R\nm m₁ m₂ : M\ninst✝ : Mul M\nH : ∀ m' ∈ x.support, m * m' = m₁ ↔ m' = m₂\n⊢ (sum x fun m' r' ↦ if m * m' = m₁ then r * r' else 0) = sum x fun m' r' ↦ if m' = m₂ then r * r' else 0",
"usedConstants": [
"Finsupp.instFunLike",
... | dsimp [Finsupp.sum]; congr! 2; simp [*] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MonoidAlgebra.Defs | {
"line": 499,
"column": 6
} | {
"line": 499,
"column": 45
} | [
{
"pp": "R : Type u_1\nM : Type u_4\ninst✝¹ : Semiring R\nx : R[M]\nr : R\nm m₁ m₂ : M\ninst✝ : Mul M\nH : ∀ m' ∈ x.support, m * m' = m₁ ↔ m' = m₂\n⊢ (sum x fun m' r' ↦ if m * m' = m₁ then r * r' else 0) = sum x fun m' r' ↦ if m' = m₂ then r * r' else 0",
"usedConstants": [
"Finsupp.instFunLike",
... | dsimp [Finsupp.sum]; congr! 2; simp [*] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.UniqueProds.Basic | {
"line": 422,
"column": 8
} | {
"line": 424,
"column": 82
} | [
{
"pp": "case neg.inl\nG : Type u_1\ninst✝¹ : Group G\ninst✝ : UniqueProds G\nA B : Finset G\nhc : A.Nonempty ∧ B.Nonempty ∧ (1 < #A ∨ 1 < #B)\na : G\nha : a ∈ A\nb : G\nhb : b ∈ B\nhu✝ : UniqueMul A B a b\nC D : Finset G\nhC✝ : 1 ∈ C\nhD : 1 ∈ D\nx✝ : Mul (Finset G) := Finset.mul\nhc1 : 1 ∈ C\nhd2 : 1 ∈ D\nhc2... | obtain ⟨c, hc, hc1⟩ := exists_mem_ne hC 1
refine (hc1 ?_).elim
simpa using hu ⟨_, ⟨_, hD, rfl⟩, _, hc, rfl⟩ ⟨_, hD, _, ⟨_, hc, rfl⟩, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.UniqueProds.Basic | {
"line": 422,
"column": 8
} | {
"line": 424,
"column": 82
} | [
{
"pp": "case neg.inl\nG : Type u_1\ninst✝¹ : Group G\ninst✝ : UniqueProds G\nA B : Finset G\nhc : A.Nonempty ∧ B.Nonempty ∧ (1 < #A ∨ 1 < #B)\na : G\nha : a ∈ A\nb : G\nhb : b ∈ B\nhu✝ : UniqueMul A B a b\nC D : Finset G\nhC✝ : 1 ∈ C\nhD : 1 ∈ D\nx✝ : Mul (Finset G) := Finset.mul\nhc1 : 1 ∈ C\nhd2 : 1 ∈ D\nhc2... | obtain ⟨c, hc, hc1⟩ := exists_mem_ne hC 1
refine (hc1 ?_).elim
simpa using hu ⟨_, ⟨_, hD, rfl⟩, _, hc, rfl⟩ ⟨_, hD, _, ⟨_, hc, rfl⟩, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Pointwise.Finset.Basic | {
"line": 994,
"column": 73
} | {
"line": 994,
"column": 81
} | [
{
"pp": "case ofNat\nα : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : DivisionMonoid α\na✝ : ℕ\nhn : Int.ofNat a✝ ≠ 0\n⊢ ∅ ^ Int.ofNat a✝ = ∅",
"usedConstants": [
"zpow_natCast",
"False",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"Finset.divisionMonoid",
"eq_fals... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.Group.Pointwise.Finset.Basic | {
"line": 994,
"column": 73
} | {
"line": 994,
"column": 81
} | [
{
"pp": "case negSucc\nα : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : DivisionMonoid α\na✝ : ℕ\nhn : Int.negSucc a✝ ≠ 0\n⊢ ∅ ^ Int.negSucc a✝ = ∅",
"usedConstants": [
"False",
"DivInvMonoid.toInv",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"Finset.divisionMonoid",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.LinearAlgebra.FreeModule.Basic | {
"line": 196,
"column": 25
} | {
"line": 196,
"column": 33
} | [
{
"pp": "R : Type u_2\nM : Type u_3\ninst✝³ : Semiring R\ninst✝² : AddCommMonoid M\ninst✝¹ : Module R M\ninst✝ : Free R M\nf : End R M\n⊢ (∃ α, ∃ (h : ∀ (g : R), g * α = α * g), ∀ (x : M), f x = (smulLeft α ⋯) x) →\n ∀ (g : End R M) (x : M), g (f x) = f (g x)",
"usedConstants": [
"Iff.mpr",
"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.LinearAlgebra.FreeModule.Basic | {
"line": 196,
"column": 25
} | {
"line": 196,
"column": 33
} | [
{
"pp": "R : Type u_2\nM : Type u_3\ninst✝³ : Semiring R\ninst✝² : AddCommMonoid M\ninst✝¹ : Module R M\ninst✝ : Free R M\nf : End R M\n⊢ (∃ α, ∃ (h : ∀ (g : R), g * α = α * g), ∀ (x : M), f x = (smulLeft α ⋯) x) →\n ∀ (g : End R M) (x : M), g (f x) = f (g x)",
"usedConstants": [
"Iff.mpr",
"... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.LinearAlgebra.FreeModule.Basic | {
"line": 196,
"column": 25
} | {
"line": 196,
"column": 33
} | [
{
"pp": "R : Type u_2\nM : Type u_3\ninst✝³ : Semiring R\ninst✝² : AddCommMonoid M\ninst✝¹ : Module R M\ninst✝ : Free R M\nf : End R M\n⊢ (∃ α, ∃ (h : ∀ (g : R), g * α = α * g), ∀ (x : M), f x = (smulLeft α ⋯) x) →\n ∀ (g : End R M) (x : M), g (f x) = f (g x)",
"usedConstants": [
"Iff.mpr",
"... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.UniqueProds.Basic | {
"line": 525,
"column": 6
} | {
"line": 525,
"column": 42
} | [
{
"pp": "case refine_2.refine_2\nG✝ : Type u\nH : Type v\ninst✝³ : Mul G✝\ninst✝² : Mul H\nι : Type u_2\nG : ι → Type u_1\ninst✝¹ : (i : ι) → Mul (G i)\ninst✝ : ∀ (i : ι), TwoUniqueProds (G i)\nA✝ : Finset ((i : ι) → G i)\nx✝ : IsWellFounded (Finset ((i : ι) → G i)) fun x1 x2 ↦ x1 ⊂ x2 := isWellFounded_ssubset\... | obtain ⟨a2, ha2, b2, hb2, hu2⟩ := h2 | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Algebra.Polynomial.Basic | {
"line": 179,
"column": 19
} | {
"line": 179,
"column": 33
} | [
{
"pp": "case zero\nR : Type u\ninst✝ : Semiring R\na : R[ℕ]\n⊢ { toFinsupp := a ^ 0 } = npowRec 0 { toFinsupp := a }",
"usedConstants": [
"MulOne.toOne",
"Polynomial.instOne",
"AddMonoidAlgebra.semiring",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instAddMonoid",
"in... | simp [npowRec] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Polynomial.Basic | {
"line": 179,
"column": 19
} | {
"line": 179,
"column": 33
} | [
{
"pp": "case zero\nR : Type u\ninst✝ : Semiring R\na : R[ℕ]\n⊢ { toFinsupp := a ^ 0 } = npowRec 0 { toFinsupp := a }",
"usedConstants": [
"MulOne.toOne",
"Polynomial.instOne",
"AddMonoidAlgebra.semiring",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instAddMonoid",
"in... | simp [npowRec] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Basic | {
"line": 179,
"column": 19
} | {
"line": 179,
"column": 33
} | [
{
"pp": "case zero\nR : Type u\ninst✝ : Semiring R\na : R[ℕ]\n⊢ { toFinsupp := a ^ 0 } = npowRec 0 { toFinsupp := a }",
"usedConstants": [
"MulOne.toOne",
"Polynomial.instOne",
"AddMonoidAlgebra.semiring",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instAddMonoid",
"in... | simp [npowRec] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Basic | {
"line": 238,
"column": 2
} | {
"line": 238,
"column": 37
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\na : R[X]\n⊢ a.toFinsupp = 1 ↔ a = 1",
"usedConstants": [
"Eq.mpr",
"Polynomial.instOne",
"Nat.instMulZeroClass",
"Polynomial.toFinsupp",
"congrArg",
"Iff.rfl",
"Polynomial.toFinsupp_inj",
"id",
"Polynomial.toFinsu... | rw [← toFinsupp_one, toFinsupp_inj] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Polynomial.Basic | {
"line": 238,
"column": 2
} | {
"line": 238,
"column": 37
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\na : R[X]\n⊢ a.toFinsupp = 1 ↔ a = 1",
"usedConstants": [
"Eq.mpr",
"Polynomial.instOne",
"Nat.instMulZeroClass",
"Polynomial.toFinsupp",
"congrArg",
"Iff.rfl",
"Polynomial.toFinsupp_inj",
"id",
"Polynomial.toFinsu... | rw [← toFinsupp_one, toFinsupp_inj] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Basic | {
"line": 238,
"column": 2
} | {
"line": 238,
"column": 37
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\na : R[X]\n⊢ a.toFinsupp = 1 ↔ a = 1",
"usedConstants": [
"Eq.mpr",
"Polynomial.instOne",
"Nat.instMulZeroClass",
"Polynomial.toFinsupp",
"congrArg",
"Iff.rfl",
"Polynomial.toFinsupp_inj",
"id",
"Polynomial.toFinsu... | rw [← toFinsupp_one, toFinsupp_inj] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Basic | {
"line": 661,
"column": 43
} | {
"line": 663,
"column": 24
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\na n : ℕ\nh : a.AtLeastTwo\n⊢ (OfNat.ofNat a).coeff (n + 1) = 0",
"usedConstants": [
"Nat.cast_ofNat",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"False",
"Nat.instMulZeroClass",
"Nat.instOne",
"congrArg",
"Add... | by
rw [← Nat.cast_ofNat]
simp [-Nat.cast_ofNat] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Module.Submodule.Invariant | {
"line": 81,
"column": 2
} | {
"line": 81,
"column": 66
} | [
{
"pp": "M : Type u_2\ninst✝⁷ : AddCommMonoid M\nR : Type u_3\nS : Type u_4\ninst✝⁶ : Semiring R\ninst✝⁵ : Semiring S\ninst✝⁴ : Module R M\ninst✝³ : Module S M\ninst✝² : DistribSMul S R\ninst✝¹ : SMulCommClass R S M\ninst✝ : IsScalarTower S R M\nf : End R M\nc : Sˣ\n⊢ (c • f).invtSubmodule = f.invtSubmodule",
... | apply le_antisymm ?_ (invtSubmodule_le_invtSubmodule_smul f c.1) | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.Polynomial.Basic | {
"line": 806,
"column": 2
} | {
"line": 806,
"column": 61
} | [
{
"pp": "R : Type u\na : R\ninst✝ : Semiring R\nn : ℕ\n⊢ a • X ^ n = (monomial n) a",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"instHSMul",
"Semiring.toModule",
"instSMulOfMul",
"HMul.hMul",
"Polynomial.X_pow_eq_m... | rw [X_pow_eq_monomial, smul_monomial, smul_eq_mul, mul_one] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Polynomial.Basic | {
"line": 806,
"column": 2
} | {
"line": 806,
"column": 61
} | [
{
"pp": "R : Type u\na : R\ninst✝ : Semiring R\nn : ℕ\n⊢ a • X ^ n = (monomial n) a",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"instHSMul",
"Semiring.toModule",
"instSMulOfMul",
"HMul.hMul",
"Polynomial.X_pow_eq_m... | rw [X_pow_eq_monomial, smul_monomial, smul_eq_mul, mul_one] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Basic | {
"line": 806,
"column": 2
} | {
"line": 806,
"column": 61
} | [
{
"pp": "R : Type u\na : R\ninst✝ : Semiring R\nn : ℕ\n⊢ a • X ^ n = (monomial n) a",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"instHSMul",
"Semiring.toModule",
"instSMulOfMul",
"HMul.hMul",
"Polynomial.X_pow_eq_m... | rw [X_pow_eq_monomial, smul_monomial, smul_eq_mul, mul_one] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Basic | {
"line": 902,
"column": 2
} | {
"line": 902,
"column": 52
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np : R[X]\n⊢ (p.sum fun n a ↦ C a * X ^ n) = p",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Semiring.toModule",
"HMul.hMul",
"congrArg",
"Polynomial.sum",
"LinearMap.instFunLike",
"Polynomial.C_mul_X_pow_eq_monomial",... | simp_rw [C_mul_X_pow_eq_monomial, sum_monomial_eq] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Algebra.Polynomial.Basic | {
"line": 902,
"column": 2
} | {
"line": 902,
"column": 52
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np : R[X]\n⊢ (p.sum fun n a ↦ C a * X ^ n) = p",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Semiring.toModule",
"HMul.hMul",
"congrArg",
"Polynomial.sum",
"LinearMap.instFunLike",
"Polynomial.C_mul_X_pow_eq_monomial",... | simp_rw [C_mul_X_pow_eq_monomial, sum_monomial_eq] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Basic | {
"line": 902,
"column": 2
} | {
"line": 902,
"column": 52
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np : R[X]\n⊢ (p.sum fun n a ↦ C a * X ^ n) = p",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Semiring.toModule",
"HMul.hMul",
"congrArg",
"Polynomial.sum",
"LinearMap.instFunLike",
"Polynomial.C_mul_X_pow_eq_monomial",... | simp_rw [C_mul_X_pow_eq_monomial, sum_monomial_eq] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.StdBasis | {
"line": 164,
"column": 4
} | {
"line": 164,
"column": 12
} | [
{
"pp": "k : Type u_1\nG : Type u_2\ninst✝³ : CommSemiring k\ninst✝² : NoZeroDivisors k\ninst✝¹ : Nontrivial k\ninst✝ : Finite G\nφ : (G → k) →ₐ[k] k\nthis✝ : Fintype G\nh1 : ∑ x, φ (Pi.single x 1) = 1\nthis : ¬∃ s, φ (Pi.single s 1) ≠ 0\n⊢ False",
"usedConstants": [
"not_exists._simp_1",
"NonAs... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.