module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.Data.Set.Finite.Lemmas | {
"line": 52,
"column": 11
} | {
"line": 59,
"column": 76
} | [
{
"pp": "α : Type u\nC : Set α → Prop\nS : Set α\nh : S.Finite\nS0 : Set α\nhS0 : S0 ⊆ S\nH0 : C S0\nH1 : ∀ s ⊂ S, C s → ∃ a ∈ S \\ s, C (insert a s)\n⊢ C S",
"usedConstants": [
"Subtype.coe_mk",
"Eq.mpr",
"Finite.of_equiv",
"Preorder.toLT",
"le_rfl",
"Equiv.Set.powerset"... | by
have : Finite S := Finite.to_subtype h
have : Finite {T : Set α // T ⊆ S} := Finite.of_equiv (Set S) (Equiv.Set.powerset S).symm
rw [← Subtype.coe_mk (p := (· ⊆ S)) _ le_rfl]
rw [← Subtype.coe_mk (p := (· ⊆ S)) _ hS0] at H0
refine Finite.to_wellFoundedGT.wf.induction_bot' (fun s hs hs' ↦ ?_) H0
obtain ⟨a... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.IsNormal | {
"line": 156,
"column": 6
} | {
"line": 156,
"column": 20
} | [
{
"pp": "case inr\nα : Type u_1\nβ : Type u_2\nf : α → β\ninst✝¹ : ConditionallyCompleteLinearOrder α\ninst✝ : ConditionallyCompleteLinearOrder β\nhf : IsNormal f\nx : β\nh₁ : (f ⁻¹' Iic x).Nonempty\nh₂ : BddAbove (f ⁻¹' Iic x)\nhy : sSup (f ⁻¹' Iic x) ∈ Iic (sSup (f ⁻¹' Iic x))\n⊢ sSup (Iic x) ≤ x",
"usedC... | rw [csSup_Iic] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.IsNormal | {
"line": 156,
"column": 6
} | {
"line": 156,
"column": 20
} | [
{
"pp": "case inr\nα : Type u_1\nβ : Type u_2\nf : α → β\ninst✝¹ : ConditionallyCompleteLinearOrder α\ninst✝ : ConditionallyCompleteLinearOrder β\nhf : IsNormal f\nx : β\nh₁ : (f ⁻¹' Iic x).Nonempty\nh₂ : BddAbove (f ⁻¹' Iic x)\nhy : sSup (f ⁻¹' Iic x) ∈ Iic (sSup (f ⁻¹' Iic x))\n⊢ sSup (Iic x) ≤ x",
"usedC... | rw [csSup_Iic] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.IsNormal | {
"line": 156,
"column": 6
} | {
"line": 156,
"column": 20
} | [
{
"pp": "case inr\nα : Type u_1\nβ : Type u_2\nf : α → β\ninst✝¹ : ConditionallyCompleteLinearOrder α\ninst✝ : ConditionallyCompleteLinearOrder β\nhf : IsNormal f\nx : β\nh₁ : (f ⁻¹' Iic x).Nonempty\nh₂ : BddAbove (f ⁻¹' Iic x)\nhy : sSup (f ⁻¹' Iic x) ∈ Iic (sSup (f ⁻¹' Iic x))\n⊢ sSup (Iic x) ≤ x",
"usedC... | rw [csSup_Iic] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Finiteness.Basic | {
"line": 205,
"column": 4
} | {
"line": 219,
"column": 21
} | [
{
"pp": "case mpr\nR : Type u_1\nM : Type u_2\ninst✝² : Semiring R\ninst✝¹ : AddCommMonoid M\ninst✝ : Module R M\ns : Submodule R M\nsp : M → Submodule R M := ⋯\nsupr_rw : ∀ (t : Finset M), ⨆ x ∈ t, sp x = ⨆ x ∈ ↑t, sp x\n⊢ IsCompactElement s → s.FG",
"usedConstants": [
"Eq.mpr",
"Submodule",
... | · intro h
rw [CompleteLattice.isCompactElement_iff_exists_le_sSup_of_le_sSup] at h
-- s is the Sup of the spans of its elements.
have sSup' : s = sSup (sp '' ↑s) := by
rw [sSup_eq_iSup, iSup_image, ← span_eq_iSup_of_singleton_spans, eq_comm, span_eq]
-- by h, s is then below (and equal t... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Order.Module.Defs | {
"line": 1141,
"column": 46
} | {
"line": 1144,
"column": 43
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\na a₁ a₂ : α\nb b₁ b₂ : β\nγ : Type u_3\ninst✝⁹ : Zero α\ninst✝⁸ : Preorder α\ninst✝⁷ : Preorder β\ninst✝⁶ : Preorder γ\ninst✝⁵ : SMul α β\ninst✝⁴ : SMul α γ\ninst✝³ : Zero β\ninst✝² : Zero γ\ninst✝¹ : SMulPosReflectLE α β\ninst✝ : SMulPosReflectLE α γ\n_b : β × γ\nhb : 0 < _... | by
rcases lt_iff.mp hb with ⟨h₁, -⟩ | ⟨-, h₁⟩
· exact le_of_smul_le_smul_right h.1 h₁
· exact le_of_smul_le_smul_right h.2 h₁ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Ordinal.Univ | {
"line": 71,
"column": 8
} | {
"line": 71,
"column": 13
} | [
{
"pp": "b : Ordinal.{max (u + 1) v}\nβ : Type (max (u + 1) v)\ns : β → β → Prop\ninst✝ : IsWellOrder β s\n⊢ type s ∈ Set.range ⇑liftInitialSeg.toRelEmbedding ↔ type s < univ.{u, v}",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"PartialOrde... | univ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 510,
"column": 2
} | {
"line": 510,
"column": 48
} | [
{
"pp": "a b c : Ordinal.{u_4}\nhb : IsSuccLimit b\n⊢ a + b ≤ c ↔ ∀ d < b, a + d ≤ c",
"usedConstants": [
"not_exists._simp_1",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Exists"... | simpa using (lt_add_iff_of_isSuccLimit hb).not | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 510,
"column": 2
} | {
"line": 510,
"column": 48
} | [
{
"pp": "a b c : Ordinal.{u_4}\nhb : IsSuccLimit b\n⊢ a + b ≤ c ↔ ∀ d < b, a + d ≤ c",
"usedConstants": [
"not_exists._simp_1",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Exists"... | simpa using (lt_add_iff_of_isSuccLimit hb).not | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 510,
"column": 2
} | {
"line": 510,
"column": 48
} | [
{
"pp": "a b c : Ordinal.{u_4}\nhb : IsSuccLimit b\n⊢ a + b ≤ c ↔ ∀ d < b, a + d ≤ c",
"usedConstants": [
"not_exists._simp_1",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Exists"... | simpa using (lt_add_iff_of_isSuccLimit hb).not | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 521,
"column": 2
} | {
"line": 521,
"column": 78
} | [
{
"pp": "a b : Ordinal.{u_4}\nha : IsSuccPrelimit a\nh : b < a\n⊢ IsSuccLimit (a - b)",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Order.succ",
"Order.IsSuccPrelimit",
"Ordinal.partialOrder",
"Order.isSuccPrelimit_iff_succ_lt",
"congrArg",
"PartialOrder.to... | rw [isSuccLimit_iff, Ordinal.sub_ne_zero_iff_lt, isSuccPrelimit_iff_succ_lt] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Ordinal.Basic | {
"line": 731,
"column": 75
} | {
"line": 732,
"column": 37
} | [
{
"pp": "a b : Ordinal.{v}\n⊢ lift.{u, v} a < lift.{u, v} b ↔ a < b",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"Ordinal.lift_le._simp_1",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Ordinal.lift",
"id",
"LE... | by
simp_rw [lt_iff_le_not_ge, lift_le] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 632,
"column": 2
} | {
"line": 632,
"column": 47
} | [
{
"pp": "a b c : Ordinal.{u_4}\nh : IsSuccLimit c\n⊢ a < b * c ↔ ∃ c' < c, a < b * c'",
"usedConstants": [
"Ordinal.instLinearOrder",
"Preorder.toLT",
"HMul.hMul",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.t... | simpa using (mul_le_iff_of_isSuccLimit h).not | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 632,
"column": 2
} | {
"line": 632,
"column": 47
} | [
{
"pp": "a b c : Ordinal.{u_4}\nh : IsSuccLimit c\n⊢ a < b * c ↔ ∃ c' < c, a < b * c'",
"usedConstants": [
"Ordinal.instLinearOrder",
"Preorder.toLT",
"HMul.hMul",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.t... | simpa using (mul_le_iff_of_isSuccLimit h).not | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 632,
"column": 2
} | {
"line": 632,
"column": 47
} | [
{
"pp": "a b c : Ordinal.{u_4}\nh : IsSuccLimit c\n⊢ a < b * c ↔ ∃ c' < c, a < b * c'",
"usedConstants": [
"Ordinal.instLinearOrder",
"Preorder.toLT",
"HMul.hMul",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.t... | simpa using (mul_le_iff_of_isSuccLimit h).not | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Basic | {
"line": 1175,
"column": 68
} | {
"line": 1175,
"column": 74
} | [
{
"pp": "a : Cardinal.{u_1}\nha : IsSuccLimit a\n⊢ ∀ ⦃a_1 : Ordinal.{u_1}⦄, (∀ ⦃x : Cardinal.{u_1}⦄, x ∈ Iio a → x.ord ≤ a_1) → a.ord ≤ a_1",
"usedConstants": [
"Eq.mpr",
"Ordinal.instLinearOrder",
"Ordinal.partialOrder",
"Cardinal",
"PartialOrder.toPreorder",
"_private.M... | ord_le | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.SetTheory.Ordinal.Basic | {
"line": 1291,
"column": 2
} | {
"line": 1291,
"column": 79
} | [
{
"pp": "o : Ordinal.{u_1}\nn : ℕ\n⊢ ↑n < o.card ↔ ↑n < o",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Preorder.toLT",
"Cardinal.instOne",
"Order.succ",
"AddMonoid.toAddSemigroup",
"Ordinal.partialOrder",
"Cardinal",
"congrA... | rw [← natCast_add_one_le_iff, ← succ_le_iff, ← Nat.cast_add_one, nat_le_card] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Log | {
"line": 93,
"column": 2
} | {
"line": 93,
"column": 36
} | [
{
"pp": "b n fuel : ℕ\nhb : 1 < b\nhn : n ≠ 0\nhfuel : 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)",
"usedConstants": [
"_private.Mathlib.Data.Nat.Log.0.Nat.log.go_spec._simp_1_4",
"instPowNat",
"Eq.mpr",
... | induction fuel generalizing b with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.SetTheory.Ordinal.Family | {
"line": 1033,
"column": 2
} | {
"line": 1033,
"column": 30
} | [
{
"pp": "s : Set Ordinal.{u}\nhs : Small.{u, u + 1} ↑s\nh : Small.{u, u + 1} ↑sᶜ\nthis : Small.{u, u + 1} Ordinal.{u}\n⊢ False",
"usedConstants": [
"not_small_ordinal"
]
}
] | exact not_small_ordinal this | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 987,
"column": 16
} | {
"line": 987,
"column": 92
} | [
{
"pp": "m n : ℕ\n⊢ ↑(m * (n + 1)) = ↑m * ↑(n + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"MulOne.toOne",
"Nat.mul_succ",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"MulZeroClass.toMul",
"congrArg",
"id",
"MulOne.toMul",
"AddMonoidWith... | rw [Nat.mul_succ, Nat.cast_add, natCast_mul m n, Nat.cast_succ, mul_add_one] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 987,
"column": 16
} | {
"line": 987,
"column": 92
} | [
{
"pp": "m n : ℕ\n⊢ ↑(m * (n + 1)) = ↑m * ↑(n + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"MulOne.toOne",
"Nat.mul_succ",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"MulZeroClass.toMul",
"congrArg",
"id",
"MulOne.toMul",
"AddMonoidWith... | rw [Nat.mul_succ, Nat.cast_add, natCast_mul m n, Nat.cast_succ, mul_add_one] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 987,
"column": 16
} | {
"line": 987,
"column": 92
} | [
{
"pp": "m n : ℕ\n⊢ ↑(m * (n + 1)) = ↑m * ↑(n + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"MulOne.toOne",
"Nat.mul_succ",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"MulZeroClass.toMul",
"congrArg",
"id",
"MulOne.toMul",
"AddMonoidWith... | rw [Nat.mul_succ, Nat.cast_add, natCast_mul m n, Nat.cast_succ, mul_add_one] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 93,
"column": 4
} | {
"line": 93,
"column": 45
} | [
{
"pp": "case limit\nb : Ordinal.{u_1}\nl : IsSuccLimit b\nIH : ∀ o' < b, 1 ^ o' = 1\nc : Ordinal.{u_1}\n⊢ 1 ^ b ≤ c ↔ 1 ≤ c",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"... | rw [opow_le_of_isSuccLimit one_ne_zero l] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Log | {
"line": 370,
"column": 2
} | {
"line": 370,
"column": 36
} | [
{
"pp": "n b fuel : ℕ\nhn : 1 < n\nhb : 1 < b\nhfuel : n < b ^ fuel\n⊢ (go n b fuel).fst = b ^ ((go n b fuel).snd + 1) / n ∧ b ^ (go n b fuel).snd < n ∧ n ≤ b ^ ((go n b fuel).snd + 1)",
"usedConstants": [
"_private.Mathlib.Data.Nat.Log.0.Nat.clog.go_spec._simp_1_4",
"instPowNat",
"Eq.mpr"... | induction fuel generalizing b with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.SetTheory.Ordinal.Principal | {
"line": 112,
"column": 12
} | {
"line": 112,
"column": 39
} | [
{
"pp": "case zero\na o : Ordinal.{u}\nop : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}\nhao : a < o\nho : IsPrincipal op o\n⊢ (op a)^[0] a < o",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"Function.iterate_zero",
"PartialOrder.toPreorde... | rwa [Function.iterate_zero] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.SetTheory.Ordinal.Principal | {
"line": 112,
"column": 12
} | {
"line": 112,
"column": 39
} | [
{
"pp": "case zero\na o : Ordinal.{u}\nop : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}\nhao : a < o\nho : IsPrincipal op o\n⊢ (op a)^[0] a < o",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"Function.iterate_zero",
"PartialOrder.toPreorde... | rwa [Function.iterate_zero] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Principal | {
"line": 112,
"column": 12
} | {
"line": 112,
"column": 39
} | [
{
"pp": "case zero\na o : Ordinal.{u}\nop : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}\nhao : a < o\nho : IsPrincipal op o\n⊢ (op a)^[0] a < o",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"Function.iterate_zero",
"PartialOrder.toPreorde... | rwa [Function.iterate_zero] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.FixedPoint | {
"line": 387,
"column": 2
} | {
"line": 393,
"column": 8
} | [
{
"pp": "a : Ordinal.{u_1}\n⊢ nfp 0 a = a",
"usedConstants": [
"Eq.mpr",
"le_refl",
"Ordinal.partialOrder",
"congrArg",
"instIsBotZeroClass",
"iSup",
"zero_le._simp_1",
"Ordinal.iSup_le",
"AddMonoid.toAddZeroClass",
"Function.iterate_succ'",
... | rw [← iSup_iterate_eq_nfp]
apply (Ordinal.iSup_le ?_).antisymm (Ordinal.le_iSup _ 0)
intro n
cases n
· rfl
· rw [Function.iterate_succ']
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.FixedPoint | {
"line": 387,
"column": 2
} | {
"line": 393,
"column": 8
} | [
{
"pp": "a : Ordinal.{u_1}\n⊢ nfp 0 a = a",
"usedConstants": [
"Eq.mpr",
"le_refl",
"Ordinal.partialOrder",
"congrArg",
"instIsBotZeroClass",
"iSup",
"zero_le._simp_1",
"Ordinal.iSup_le",
"AddMonoid.toAddZeroClass",
"Function.iterate_succ'",
... | rw [← iSup_iterate_eq_nfp]
apply (Ordinal.iSup_le ?_).antisymm (Ordinal.le_iSup _ 0)
intro n
cases n
· rfl
· rw [Function.iterate_succ']
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 369,
"column": 8
} | {
"line": 369,
"column": 28
} | [
{
"pp": "case inl\nb x : Ordinal.{u_1}\nhx : x ≠ 0\nhb : b ≤ 1\n⊢ b ^ log b x ≤ x",
"usedConstants": [
"Ordinal.partialOrder",
"congrArg",
"instIsBotZeroClass",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"... | ← one_le_iff_ne_zero | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 435,
"column": 6
} | {
"line": 435,
"column": 44
} | [
{
"pp": "case right\nb u v w : Ordinal.{u_1}\nhb : 1 < b\nhv : v ≠ 0\nhw : w < b ^ u\n⊢ b ^ u * v + w < b ^ (u + log b v + 1)",
"usedConstants": [
"add_lt_add_right",
"Preorder.toLT",
"HMul.hMul",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"PartialOrder.toPreorder",
... | apply (add_lt_add_right hw _).trans_le | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.SetTheory.Ordinal.FixedPoint | {
"line": 479,
"column": 12
} | {
"line": 479,
"column": 32
} | [
{
"pp": "case inr\na b : Ordinal.{u_1}\nhab : a * b = b\nha : 0 < a\nhb : b ≠ 0\n⊢ nfp (fun x ↦ a * x) 1 ≤ b",
"usedConstants": [
"Ordinal.partialOrder",
"congrArg",
"instIsBotZeroClass",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddZe... | ← one_le_iff_ne_zero | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.FixedPoint | {
"line": 505,
"column": 2
} | {
"line": 508,
"column": 66
} | [
{
"pp": "case a\na c b : Ordinal.{u_1}\nha : 0 < a\nhc : 0 < c\nhca : c ≤ a ^ ω\n⊢ nfp (fun x ↦ a * x) (a ^ ω * b + c) ≤ a ^ ω * succ b",
"usedConstants": [
"Eq.mpr",
"Ordinal.isNormal_mul_right",
"le_refl",
"Semigroup.toMul",
"Ordinal.instLinearOrder",
"HMul.hMul",
... | · apply nfp_le_fp (isNormal_mul_right ha).monotone
· rw [mul_succ]
gcongr
· dsimp only; rw [← mul_assoc, ← opow_one_add, one_add_omega0] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 504,
"column": 4
} | {
"line": 504,
"column": 40
} | [
{
"pp": "case mp\na b : Ordinal.{u_1}\nhb : b ≠ 0\n⊢ (∃ c, (∃ c_1 < b, ∃ n, c < ω ^ c_1 * ↑n) ∧ ∃ n, a < ω ^ c * ↑n) → ∃ c < b, ∃ n, a < ω ^ (ω ^ c * ↑n)",
"usedConstants": [
"Preorder.toLT",
"HMul.hMul",
"Ordinal.omega0",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"Pa... | intro ⟨a, ⟨b, hb, ⟨m, hm⟩⟩, ⟨n, hn⟩⟩ | Lean.Elab.Tactic.evalIntro | null |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 504,
"column": 4
} | {
"line": 504,
"column": 40
} | [
{
"pp": "case mp\na b : Ordinal.{u_1}\nhb : b ≠ 0\n⊢ (∃ c, (∃ c_1 < b, ∃ n, c < ω ^ c_1 * ↑n) ∧ ∃ n, a < ω ^ c * ↑n) → ∃ c < b, ∃ n, a < ω ^ (ω ^ c * ↑n)",
"usedConstants": [
"Preorder.toLT",
"HMul.hMul",
"Ordinal.omega0",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"Pa... | intro ⟨a, ⟨b, hb, ⟨m, hm⟩⟩, ⟨n, hn⟩⟩ | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.SetTheory.Ordinal.Principal | {
"line": 340,
"column": 6
} | {
"line": 340,
"column": 35
} | [
{
"pp": "case right\na b : Ordinal.{u}\nhb₁ : b ≠ 1\nhb : IsPrincipal (fun x1 x2 ↦ x1 + x2) b\nh✝ : 0 < a\nhb₁' : 1 ≤ b\nc d x : Ordinal.{u}\nhx : x < b\nhx' : c < a * x\ny : Ordinal.{u}\nhy : y < b\nhy' : d < a * y\n⊢ (fun x1 x2 ↦ x1 + x2) c d < a * x + a * y",
"usedConstants": [
"Ordinal.instAddRigh... | exact Left.add_lt_add hx' hy' | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.Cardinal.Aleph | {
"line": 104,
"column": 6
} | {
"line": 104,
"column": 12
} | [
{
"pp": "a : Ordinal.{u_1}\nha : a ∈ upperBounds {x | x.IsInitial}\nthis : (succ a.card).ord ≤ a\n⊢ False",
"usedConstants": [
"Order.succ",
"Ordinal.partialOrder",
"Cardinal",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Cardinal.instSuccOrder",
"... | ord_le | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Cardinal.Aleph | {
"line": 595,
"column": 2
} | {
"line": 600,
"column": 64
} | [
{
"pp": "o : Ordinal.{u_1}\nho : IsSuccPrelimit o\n⊢ preBeth o = ⨆ a, preBeth ↑a",
"usedConstants": [
"Eq.mpr",
"Order.succ",
"Cardinal.instPowCardinal",
"Ordinal.partialOrder",
"Cardinal",
"Cardinal.preBeth.eq_1",
"LE.le.antisymm'",
"congrArg",
"iSup",
... | rw [preBeth]
apply (ciSup_mono bddAbove_of_small fun _ ↦ (cantor _).le).antisymm'
rw [ciSup_le_iff' bddAbove_of_small]
intro a
rw [← preBeth_succ]
exact le_ciSup bddAbove_of_small (⟨_, ho.succ_lt a.2⟩ : Iio o) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Cardinal.Aleph | {
"line": 595,
"column": 2
} | {
"line": 600,
"column": 64
} | [
{
"pp": "o : Ordinal.{u_1}\nho : IsSuccPrelimit o\n⊢ preBeth o = ⨆ a, preBeth ↑a",
"usedConstants": [
"Eq.mpr",
"Order.succ",
"Cardinal.instPowCardinal",
"Ordinal.partialOrder",
"Cardinal",
"Cardinal.preBeth.eq_1",
"LE.le.antisymm'",
"congrArg",
"iSup",
... | rw [preBeth]
apply (ciSup_mono bddAbove_of_small fun _ ↦ (cantor _).le).antisymm'
rw [ciSup_le_iff' bddAbove_of_small]
intro a
rw [← preBeth_succ]
exact le_ciSup bddAbove_of_small (⟨_, ho.succ_lt a.2⟩ : Iio o) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Cardinal.Regular | {
"line": 81,
"column": 2
} | {
"line": 81,
"column": 9
} | [
{
"pp": "c : Cardinal.{u_1}\nhc : ℵ₀ ≤ c\nhc₀ : ℵ₀ ≤ succ c\n⊢ (succ c).IsRegular",
"usedConstants": [
"Cardinal.IsRegular.mk",
"Order.succ",
"Cardinal",
"PartialOrder.toPreorder",
"Cardinal.instSuccOrder",
"Cardinal.partialOrder"
]
}
] | use hc₀ | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | {
"line": 304,
"column": 79
} | {
"line": 305,
"column": 40
} | [
{
"pp": "α : Type u\nf : α → Ordinal.{u}\n⊢ (⨆ i, f i + 1).cof ≤ #α",
"usedConstants": [
"Cardinal",
"Ordinal.lift_id",
"congrArg",
"iSup",
"Cardinal.lift",
"Ordinal.lift",
"Cardinal.mk",
"Eq.mp",
"UnivLE.small",
"LE.le",
"ConditionallyComple... | by
simpa using cof_lift_iSup_add_one_le f | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Cardinal.Pigeonhole | {
"line": 32,
"column": 2
} | {
"line": 38,
"column": 82
} | [
{
"pp": "β α : Type u\nf : β → α\nh₁ : ℵ₀ ≤ #β\nh₂ : #α < (#β).ord.cof\n⊢ ∃ a, #↑(f ⁻¹' {a}) = #β",
"usedConstants": [
"Mathlib.Tactic.Push.not_exists._simp_1",
"Eq.mpr",
"Preorder.toLT",
"HMul.hMul",
"Cardinal.iSup_lt_of_lt_cof_ord",
"Cardinal.sum_le_mk_mul_iSup",
... | have : ∃ a, #β ≤ #(f ⁻¹' {a}) := by
by_contra! h
apply mk_univ.not_lt
rw [← preimage_univ, ← iUnion_of_singleton, preimage_iUnion]
exact
mk_iUnion_le_sum_mk.trans_lt <| (sum_le_mk_mul_iSup _).trans_lt <|
mul_lt_of_lt h₁ (h₂.trans_le <| cof_ord_le _) (iSup_lt_of_lt_cof_ord h₂ h) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 191,
"column": 8
} | {
"line": 191,
"column": 26
} | [
{
"pp": "case right.right\na : Cardinal.{u_1}\nha : ℵ₀ ≤ a\nthis : a ≠ 0\nh : a * 0 = a\n⊢ a = 0",
"usedConstants": [
"HMul.hMul",
"Cardinal",
"MulZeroClass.toMul",
"congrArg",
"CommSemiring.toSemiring",
"Cardinal.commSemiring",
"Eq.mp",
"MulZeroClass.mul_zero... | rw [mul_zero] at h | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 199,
"column": 6
} | {
"line": 199,
"column": 24
} | [
{
"pp": "a : Cardinal.{u_1}\nha : a < ℵ₀\nh2a : ¬a = 0\nh : a * 0 = a\n⊢ a = 0",
"usedConstants": [
"HMul.hMul",
"Cardinal",
"MulZeroClass.toMul",
"congrArg",
"CommSemiring.toSemiring",
"Cardinal.commSemiring",
"Eq.mp",
"MulZeroClass.mul_zero",
"Zero.toO... | rw [mul_zero] at h | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | {
"line": 559,
"column": 11
} | {
"line": 559,
"column": 16
} | [
{
"pp": "⊢ univ.{u, v}.card ≤ univ.{u, v}.cof",
"usedConstants": [
"Cardinal",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Ordinal.univ",
"id",
"LE.le",
"Ordinal.card",
"Cardinal.partialOrder",
"Ordinal.cof"
]
}
] | univ, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 306,
"column": 2
} | {
"line": 308,
"column": 23
} | [
{
"pp": "case refine_2\na b : Cardinal.{u_1}\n⊢ ℵ₀ ≤ a ∧ b ≤ a ∨ b = 0 → a + b = a",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Lattice.toSemilatticeSup",
"Cardinal",
"congrArg",
"CommSemiring.toSemiring",
"AddMonoid.toAddZeroClass",
... | · rintro (⟨h1, h2⟩ | h3)
· rw [add_eq_max h1, max_eq_left h2]
· rw [h3, add_zero] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 338,
"column": 8
} | {
"line": 338,
"column": 32
} | [
{
"pp": "case inl\na b c : Cardinal.{u_1}\nh : a + b = a + c\nha : a < ℵ₀\nhb : ℵ₀ ≤ b\nthis : a < b\n⊢ b = c",
"usedConstants": [
"Cardinal",
"congrArg",
"PartialOrder.toPreorder",
"Eq.mp",
"LT.lt.le",
"Cardinal.instAdd",
"instHAdd",
"Cardinal.partialOrder",
... | add_eq_right hb this.le, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 623,
"column": 6
} | {
"line": 623,
"column": 35
} | [
{
"pp": "α β : Type u\n⊢ #(α ≃ β) = 0 ↔ #α ≠ #β",
"usedConstants": [
"Eq.mpr",
"Cardinal",
"congrArg",
"Cardinal.lift",
"Cardinal.mk",
"id",
"Equiv",
"Ne",
"Iff",
"propext",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"Cardinal.mk... | mk_equiv_eq_zero_iff_lift_ne, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.DFinsupp.Sigma | {
"line": 93,
"column": 4
} | {
"line": 94,
"column": 20
} | [
{
"pp": "case h.h.inl.inr\nι : Type u\nα : ι → Type u_2\nδ : (i : ι) → α i → Type v\ninst✝² : DecidableEq ι\ninst✝¹ : (i : ι) → DecidableEq (α i)\ninst✝ : (i : ι) → (j : α i) → Zero (δ i j)\ni : ι\nj : α i\nx : δ ⟨i, j⟩.fst ⟨i, j⟩.snd\nj' : α i\nhj : j' ≠ j\n⊢ (single ⟨i, j⟩ x) ⟨i, j'⟩ = (single j x) j'",
"... | · rw [single_eq_of_ne, single_eq_of_ne hj]
simpa using hj | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Fintype.Quotient | {
"line": 186,
"column": 2
} | {
"line": 186,
"column": 45
} | [
{
"pp": "case h.h\nι : Type u_1\ninst✝¹ : Fintype ι\ninst✝ : DecidableEq ι\nα : ι → Sort u_2\nS : (i : ι) → Setoid (α i)\nC : ((i : ι) → Quotient (S i)) → Sort u_4\na : (i : ι) → α i\nf : (a : (i : ι) → α i) → C fun x ↦ ⟦a x⟧\nh : ∀ (a b : (i : ι) → α i), (∀ (i : ι), a i ≈ b i) → f a ≍ f b\n⊢ finHRecOn (fun x ↦... | refine eq_of_heq ((eqRec_heq _ _).trans ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.DFinsupp.Defs | {
"line": 766,
"column": 6
} | {
"line": 767,
"column": 17
} | [
{
"pp": "case pos\nι : Type u\nβ : ι → Type v\ninst✝¹ : DecidableEq ι\ninst✝ : (i : ι) → AddZeroClass (β i)\np : (Π₀ (i : ι), β i) → Prop\nf✝ : Π₀ (i : ι), β i\nh0 : p 0\nha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), f i = 0 → b ≠ 0 → p f → p (f + single i b)\ni : ι\nb : β i\nf : Π₀ (i : ι), β i\nh1 : f i = 0... | · subst H
simp [h1] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.LinearAlgebra.Dual.Defs | {
"line": 238,
"column": 6
} | {
"line": 238,
"column": 43
} | [
{
"pp": "R : Type u_3\nM : Type u_4\ninst✝³ : CommSemiring R\ninst✝² : AddCommMonoid M\ninst✝¹ : Module R M\ninst✝ : IsReflexive R M\nf : Dual R M\ng : Dual R (Dual R M)\nm : M := (evalEquiv R M).symm g\n⊢ f m = g f",
"usedConstants": [
"Eq.mpr",
"LinearEquiv.symm",
"Semiring.toModule",
... | ← (evalEquiv R M).apply_symm_apply g, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.DFinsupp | {
"line": 108,
"column": 56
} | {
"line": 108,
"column": 74
} | [
{
"pp": "ι : Type u_1\nR : Type u_3\nM : ι → Type u_5\ninst✝³ : Semiring R\ninst✝² : (i : ι) → AddCommMonoid (M i)\ninst✝¹ : (i : ι) → Module R (M i)\ninst✝ : DecidableEq ι\ni i' : ι\nh : i ≠ i'\n⊢ lapply i ∘ₗ lsingle i' = 0",
"usedConstants": [
"Eq.recOn",
"eq_false",
"LinearMap.ext",
... | ext; simp [h.symm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.LinearAlgebra.DFinsupp | {
"line": 108,
"column": 56
} | {
"line": 108,
"column": 74
} | [
{
"pp": "ι : Type u_1\nR : Type u_3\nM : ι → Type u_5\ninst✝³ : Semiring R\ninst✝² : (i : ι) → AddCommMonoid (M i)\ninst✝¹ : (i : ι) → Module R (M i)\ninst✝ : DecidableEq ι\ni i' : ι\nh : i ≠ i'\n⊢ lapply i ∘ₗ lsingle i' = 0",
"usedConstants": [
"Eq.recOn",
"eq_false",
"LinearMap.ext",
... | ext; simp [h.symm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 412,
"column": 61
} | {
"line": 430,
"column": 80
} | [
{
"pp": "R : Type u_2\nM : Type u_4\ninst✝² : Ring R\ninst✝¹ : AddCommGroup M\ninst✝ : Module R M\nη : Type u_6\nιs : η → Type u_7\nf : (j : η) → ιs j → M\nhindep : ∀ (j : η), LinearIndependent R (f j)\nhd : ∀ (i : η) (t : Set η), t.Finite → i ∉ t → Disjoint (span R (range (f i))) (⨆ i ∈ t, span R (range (f i))... | by
nontriviality R
apply LinearIndependent.of_linearIndepOn_id_range
· rintro ⟨x₁, x₂⟩ ⟨y₁, y₂⟩ hxy
by_cases h_cases : x₁ = y₁
· subst h_cases
refine Sigma.eq rfl ?_
rw [LinearIndependent.injective (hindep _) hxy]
· have h0 : f x₁ x₂ = 0 := by
apply
disjoint_def.1 (hd x₁ ... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 734,
"column": 2
} | {
"line": 735,
"column": 82
} | [
{
"pp": "K : Type u_3\nV : Type u\ninst✝² : DivisionRing K\ninst✝¹ : AddCommGroup V\ninst✝ : Module K V\nf : Fin 2 → V\n⊢ LinearIndependent K f ↔ f 1 ≠ 0 ∧ ∀ (a : K), a • f 1 ≠ f 0",
"usedConstants": [
"Eq.mpr",
"Inhabited.default",
"Submodule",
"instNeZeroNatHAdd_1",
"instHSMu... | rw [linearIndependent_finSucc, linearIndependent_unique_iff, range_unique, mem_span_singleton,
not_exists, show Fin.tail f default = f 1 by rw [← Fin.succ_zero_eq_one]; rfl] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 734,
"column": 2
} | {
"line": 735,
"column": 82
} | [
{
"pp": "K : Type u_3\nV : Type u\ninst✝² : DivisionRing K\ninst✝¹ : AddCommGroup V\ninst✝ : Module K V\nf : Fin 2 → V\n⊢ LinearIndependent K f ↔ f 1 ≠ 0 ∧ ∀ (a : K), a • f 1 ≠ f 0",
"usedConstants": [
"Eq.mpr",
"Inhabited.default",
"Submodule",
"instNeZeroNatHAdd_1",
"instHSMu... | rw [linearIndependent_finSucc, linearIndependent_unique_iff, range_unique, mem_span_singleton,
not_exists, show Fin.tail f default = f 1 by rw [← Fin.succ_zero_eq_one]; rfl] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 734,
"column": 2
} | {
"line": 735,
"column": 82
} | [
{
"pp": "K : Type u_3\nV : Type u\ninst✝² : DivisionRing K\ninst✝¹ : AddCommGroup V\ninst✝ : Module K V\nf : Fin 2 → V\n⊢ LinearIndependent K f ↔ f 1 ≠ 0 ∧ ∀ (a : K), a • f 1 ≠ f 0",
"usedConstants": [
"Eq.mpr",
"Inhabited.default",
"Submodule",
"instNeZeroNatHAdd_1",
"instHSMu... | rw [linearIndependent_finSucc, linearIndependent_unique_iff, range_unique, mem_span_singleton,
not_exists, show Fin.tail f default = f 1 by rw [← Fin.succ_zero_eq_one]; rfl] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.AddChar | {
"line": 403,
"column": 2
} | {
"line": 403,
"column": 48
} | [
{
"pp": "A : Type u_1\nM : Type u_2\ninst✝¹ : AddCommGroup A\ninst✝ : DivisionCommMonoid M\nψ χ : AddChar A M\na : A\n⊢ (ψ / χ) a = ψ a / χ a",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul"... | rw [div_apply, map_neg_eq_inv, div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.AddChar | {
"line": 403,
"column": 2
} | {
"line": 403,
"column": 48
} | [
{
"pp": "A : Type u_1\nM : Type u_2\ninst✝¹ : AddCommGroup A\ninst✝ : DivisionCommMonoid M\nψ χ : AddChar A M\na : A\n⊢ (ψ / χ) a = ψ a / χ a",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul"... | rw [div_apply, map_neg_eq_inv, div_eq_mul_inv] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.AddChar | {
"line": 403,
"column": 2
} | {
"line": 403,
"column": 48
} | [
{
"pp": "A : Type u_1\nM : Type u_2\ninst✝¹ : AddCommGroup A\ninst✝ : DivisionCommMonoid M\nψ χ : AddChar A M\na : A\n⊢ (ψ / χ) a = ψ a / χ a",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul"... | rw [div_apply, map_neg_eq_inv, div_eq_mul_inv] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Module.BigOperators | {
"line": 34,
"column": 2
} | {
"line": 34,
"column": 43
} | [
{
"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",
... | induction s using Multiset.induction with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Finset.NAry | {
"line": 104,
"column": 94
} | {
"line": 105,
"column": 64
} | [
{
"pp": "α : Type u_1\nβ : Type u_3\nγ : Type u_5\ninst✝ : DecidableEq γ\nf : α → β → γ\ns : Finset α\nt : Finset β\nu : Finset γ\n⊢ image₂ f s t ⊆ u ↔ ∀ b ∈ t, image (fun a ↦ f a b) s ⊆ u",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"Membership.mem",
"id",
"HasSu... | by
simp_rw [image₂_subset_iff, image_subset_iff, @forall₂_comm α] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.NAry | {
"line": 132,
"column": 15
} | {
"line": 132,
"column": 40
} | [
{
"pp": "α : Type u_1\nβ : Type u_3\nγ : Type u_5\ninst✝ : DecidableEq γ\nf : α → β → γ\ns : Finset α\nt : Finset β\n⊢ (image₂ f s t).Nonempty ↔ s.Nonempty ∧ t.Nonempty",
"usedConstants": [
"Finset.image₂_nonempty_iff"
]
}
] | exact image₂_nonempty_iff | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Finset.NAry | {
"line": 217,
"column": 66
} | {
"line": 218,
"column": 54
} | [
{
"pp": "α : Type u_1\nβ : Type u_3\nγ : Type u_5\ninst✝¹ : DecidableEq γ\nf : α → β → γ\nb : β\ninst✝ : DecidableEq α\ns₁ s₂ : Finset α\nhf : Injective fun a ↦ f a b\n⊢ image₂ f (s₁ ∩ s₂) {b} = image₂ f s₁ {b} ∩ image₂ f s₂ {b}",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"F... | by
simp_rw [image₂_singleton_right, image_inter _ _ hf] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | {
"line": 102,
"column": 4
} | {
"line": 115,
"column": 55
} | [
{
"pp": "R : Type u_1\nA : Type u_2\ninst✝⁴ : Semiring R\ninst✝³ : IsCancelAdd R\ninst✝² : IsLeftCancelMulZero R\ninst✝¹ : Mul A\ninst✝ : UniqueProds A\nf : R[A]\nhf : f ≠ 0\ng₁ g₂ : R[A]\neq : (fun x ↦ f * x) g₁ = (fun x ↦ f * x) g₂\n⊢ g₁ = g₂",
"usedConstants": [
"Iff.mpr",
"Finsupp.mem_suppor... | induction hg : g₁.support ∪ g₂.support using Finset.eraseInduction generalizing g₁ g₂ with
| _ s ih =>
obtain h | h := s.eq_empty_or_nonempty <;> subst s
· simp_rw [Finset.union_eq_empty, support_eq_empty] at h; exact h.1.trans h.2.symm
obtain ⟨af, haf, ag, hag, uniq⟩ :=
UniqueProds.uniqueMul_of_n... | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | {
"line": 102,
"column": 4
} | {
"line": 115,
"column": 55
} | [
{
"pp": "R : Type u_1\nA : Type u_2\ninst✝⁴ : Semiring R\ninst✝³ : IsCancelAdd R\ninst✝² : IsLeftCancelMulZero R\ninst✝¹ : Mul A\ninst✝ : UniqueProds A\nf : R[A]\nhf : f ≠ 0\ng₁ g₂ : R[A]\neq : (fun x ↦ f * x) g₁ = (fun x ↦ f * x) g₂\n⊢ g₁ = g₂",
"usedConstants": [
"Iff.mpr",
"Finsupp.mem_suppor... | induction hg : g₁.support ∪ g₂.support using Finset.eraseInduction generalizing g₁ g₂ with
| _ s ih =>
obtain h | h := s.eq_empty_or_nonempty <;> subst s
· simp_rw [Finset.union_eq_empty, support_eq_empty] at h; exact h.1.trans h.2.symm
obtain ⟨af, haf, ag, hag, uniq⟩ :=
UniqueProds.uniqueMul_of_n... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | {
"line": 102,
"column": 4
} | {
"line": 115,
"column": 55
} | [
{
"pp": "R : Type u_1\nA : Type u_2\ninst✝⁴ : Semiring R\ninst✝³ : IsCancelAdd R\ninst✝² : IsLeftCancelMulZero R\ninst✝¹ : Mul A\ninst✝ : UniqueProds A\nf : R[A]\nhf : f ≠ 0\ng₁ g₂ : R[A]\neq : (fun x ↦ f * x) g₁ = (fun x ↦ f * x) g₂\n⊢ g₁ = g₂",
"usedConstants": [
"Iff.mpr",
"Finsupp.mem_suppor... | induction hg : g₁.support ∪ g₂.support using Finset.eraseInduction generalizing g₁ g₂ with
| _ s ih =>
obtain h | h := s.eq_empty_or_nonempty <;> subst s
· simp_rw [Finset.union_eq_empty, support_eq_empty] at h; exact h.1.trans h.2.symm
obtain ⟨af, haf, ag, hag, uniq⟩ :=
UniqueProds.uniqueMul_of_n... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.MonoidAlgebra.Defs | {
"line": 701,
"column": 2
} | {
"line": 705,
"column": 44
} | [
{
"pp": "R : Type u_1\nG : Type u_3\ninst✝¹ : Semiring R\ninst✝ : Group G\nx y : R[G]\ng : G\n⊢ (x * y) g = sum y fun h r ↦ x (g * h⁻¹) * r",
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"instDecidableNot",
"HMul.hMul",
"ite_eq_right_iff._simp_1",
"DivInvOneMonoid.... | classical
rw [mul_apply, Finsupp.sum_comm]
dsimp [Finsupp.sum]
congr! 1
simp +contextual [← eq_mul_inv_iff_mul_eq] | Lean.Elab.Tactic.evalClassical | Lean.Parser.Tactic.classical |
Mathlib.Algebra.MonoidAlgebra.Defs | {
"line": 701,
"column": 2
} | {
"line": 705,
"column": 44
} | [
{
"pp": "R : Type u_1\nG : Type u_3\ninst✝¹ : Semiring R\ninst✝ : Group G\nx y : R[G]\ng : G\n⊢ (x * y) g = sum y fun h r ↦ x (g * h⁻¹) * r",
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"instDecidableNot",
"HMul.hMul",
"ite_eq_right_iff._simp_1",
"DivInvOneMonoid.... | classical
rw [mul_apply, Finsupp.sum_comm]
dsimp [Finsupp.sum]
congr! 1
simp +contextual [← eq_mul_inv_iff_mul_eq] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MonoidAlgebra.Defs | {
"line": 701,
"column": 2
} | {
"line": 705,
"column": 44
} | [
{
"pp": "R : Type u_1\nG : Type u_3\ninst✝¹ : Semiring R\ninst✝ : Group G\nx y : R[G]\ng : G\n⊢ (x * y) g = sum y fun h r ↦ x (g * h⁻¹) * r",
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"instDecidableNot",
"HMul.hMul",
"ite_eq_right_iff._simp_1",
"DivInvOneMonoid.... | classical
rw [mul_apply, Finsupp.sum_comm]
dsimp [Finsupp.sum]
congr! 1
simp +contextual [← eq_mul_inv_iff_mul_eq] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.UniqueProds.Basic | {
"line": 181,
"column": 12
} | {
"line": 181,
"column": 79
} | [
{
"pp": "G : Type u_1\nH : Type u_2\ninst✝¹ : Mul G\ninst✝ : Mul H\nA B : Finset G\na0 b0 : G\nf : G ↪ H\nmul : ∀ (x y : G), f (x * y) = f x * f y\n⊢ UniqueMul (map f A) (map f B) (f a0) (f b0) ↔ UniqueMul A B a0 b0",
"usedConstants": [
"MulHom",
"Eq.mpr",
"UniqueMul",
"congrArg",
... | simp_rw [← mulHom_image_iff ⟨f, mul⟩ f.2, Finset.map_eq_image]; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.UniqueProds.Basic | {
"line": 181,
"column": 12
} | {
"line": 181,
"column": 79
} | [
{
"pp": "G : Type u_1\nH : Type u_2\ninst✝¹ : Mul G\ninst✝ : Mul H\nA B : Finset G\na0 b0 : G\nf : G ↪ H\nmul : ∀ (x y : G), f (x * y) = f x * f y\n⊢ UniqueMul (map f A) (map f B) (f a0) (f b0) ↔ UniqueMul A B a0 b0",
"usedConstants": [
"MulHom",
"Eq.mpr",
"UniqueMul",
"congrArg",
... | simp_rw [← mulHom_image_iff ⟨f, mul⟩ f.2, Finset.map_eq_image]; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.UniqueProds.Basic | {
"line": 407,
"column": 6
} | {
"line": 407,
"column": 59
} | [
{
"pp": "case refine_3\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\nhcard : 1 < #C ∨ 1 < #D\nhC : 1 ∈ C\nhD : 1 ∈ D\nx✝ : Mul (Finset G) := Finset.mul\ne : ... | simp only [UniqueMul, mem_mul, mem_image] at he hf hu | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Finset.Sort | {
"line": 122,
"column": 6
} | {
"line": 122,
"column": 30
} | [
{
"pp": "α : Type u_1\ns : Finset α\nr : α → α → Prop\ninst✝⁴ : DecidableRel r\ninst✝³ : IsTrans α r\ninst✝² : Std.Antisymm r\ninst✝¹ : Std.Total r\ninst✝ : DecidableEq α\na : α\nh₁ : ∀ b ∈ s, r a b\nh₂ : a ∉ s\n⊢ (insert a s).sort r = a :: s.sort r",
"usedConstants": [
"Eq.mpr",
"Finset.cons",
... | ← cons_eq_insert _ _ h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Finset.Sort | {
"line": 211,
"column": 40
} | {
"line": 211,
"column": 70
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝ : LinearOrder α\ns : Finset α\nk : ℕ\nh : #s = k\ni : Fin k\n⊢ ↑i < (s.sort fun a b ↦ a ≤ b).length",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Fin.isLt",
"SemilatticeInf.toPartialOrder... | rw [length_sort, h]; exact i.2 | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Sort | {
"line": 211,
"column": 40
} | {
"line": 211,
"column": 70
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝ : LinearOrder α\ns : Finset α\nk : ℕ\nh : #s = k\ni : Fin k\n⊢ ↑i < (s.sort fun a b ↦ a ≤ b).length",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Fin.isLt",
"SemilatticeInf.toPartialOrder... | rw [length_sort, h]; exact i.2 | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Basic | {
"line": 919,
"column": 10
} | {
"line": 919,
"column": 23
} | [
{
"pp": "case insert\nR : Type u\ninst✝ : Semiring R\nmotive : R[X] → Prop\np : R[X]\nC : ∀ (a : R), motive (Polynomial.C a)\nadd : ∀ (p q : R[X]), motive p → motive q → motive (p + q)\nmonomial : ∀ (n : ℕ) (a : R), motive (Polynomial.C a * X ^ n) → motive (Polynomial.C a * X ^ (n + 1))\nA : ∀ {n : ℕ} {a : R}, ... | sum_insert ns | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Finiteness.Finsupp | {
"line": 71,
"column": 2
} | {
"line": 73,
"column": 22
} | [
{
"pp": "case a\nR : Type u_1\nM : Type u_2\nP : Type u_4\ninst✝⁴ : Ring R\ninst✝³ : AddCommGroup M\ninst✝² : Module R M\ninst✝¹ : AddCommGroup P\ninst✝ : Module R P\nf : M →ₗ[R] P\ns : Submodule R M\nthis✝¹ : DecidableEq R\nthis✝ : DecidableEq M\nthis : DecidableEq P\nt1 : Finset P\nht1 : span R ↑t1 = map f s\... | have : f x ∈ s.map f := by
rw [mem_map]
exact ⟨x, hx, rfl⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Module.Submodule.Bilinear | {
"line": 67,
"column": 6
} | {
"line": 70,
"column": 47
} | [
{
"pp": "case a.mem\nR : Type u_1\nM : Type u_2\nN : Type u_3\nP : Type u_4\ninst✝⁶ : CommSemiring R\ninst✝⁵ : AddCommMonoid M\ninst✝⁴ : AddCommMonoid N\ninst✝³ : AddCommMonoid P\ninst✝² : Module R M\ninst✝¹ : Module R N\ninst✝ : Module R P\nf : M →ₗ[R] N →ₗ[R] P\ns : Set M\nt : Set N\n⊢ ∀ x ∈ s, ∀ n ∈ span R t... | intro a ha
apply @span_induction R N _ _ _ t
· intro b hb
exact subset_span ⟨_, ‹_›, _, ‹_›, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Module.Submodule.Bilinear | {
"line": 67,
"column": 6
} | {
"line": 70,
"column": 47
} | [
{
"pp": "case a.mem\nR : Type u_1\nM : Type u_2\nN : Type u_3\nP : Type u_4\ninst✝⁶ : CommSemiring R\ninst✝⁵ : AddCommMonoid M\ninst✝⁴ : AddCommMonoid N\ninst✝³ : AddCommMonoid P\ninst✝² : Module R M\ninst✝¹ : Module R N\ninst✝ : Module R P\nf : M →ₗ[R] N →ₗ[R] P\ns : Set M\nt : Set N\n⊢ ∀ x ∈ s, ∀ n ∈ span R t... | intro a ha
apply @span_induction R N _ _ _ t
· intro b hb
exact subset_span ⟨_, ‹_›, _, ‹_›, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.TensorProduct.Defs | {
"line": 333,
"column": 25
} | {
"line": 333,
"column": 36
} | [
{
"pp": "R : Type u_1\nR₂ : Type u_2\nR₃ : Type u_3\nR' : Type u_4\nR'' : Type u_5\ninst✝³⁸ : CommSemiring R\ninst✝³⁷ : CommSemiring R₂\ninst✝³⁶ : CommSemiring R₃\ninst✝³⁵ : Monoid R'\ninst✝³⁴ : Semiring R''\nσ₁₂ : R →+* R₂\nσ₂₃ : R₂ →+* R₃\nσ₁₃ : R →+* R₃\nA : Type u_6\nM : Type u_7\nN : Type u_8\nP : Type u_9... | smul_tmul', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.TensorProduct.Defs | {
"line": 333,
"column": 37
} | {
"line": 333,
"column": 48
} | [
{
"pp": "R : Type u_1\nR₂ : Type u_2\nR₃ : Type u_3\nR' : Type u_4\nR'' : Type u_5\ninst✝³⁸ : CommSemiring R\ninst✝³⁷ : CommSemiring R₂\ninst✝³⁶ : CommSemiring R₃\ninst✝³⁵ : Monoid R'\ninst✝³⁴ : Semiring R''\nσ₁₂ : R →+* R₂\nσ₂₃ : R₂ →+* R₃\nσ₁₃ : R →+* R₃\nA : Type u_6\nM : Type u_7\nN : Type u_8\nP : Type u_9... | smul_tmul', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.TensorProduct.Defs | {
"line": 346,
"column": 30
} | {
"line": 346,
"column": 41
} | [
{
"pp": "R : Type u_1\nR₂ : Type u_2\nR₃ : Type u_3\nR' : Type u_4\nR'' : Type u_5\ninst✝⁴⁰ : CommSemiring R\ninst✝³⁹ : CommSemiring R₂\ninst✝³⁸ : CommSemiring R₃\ninst✝³⁷ : Monoid R'\ninst✝³⁶ : Semiring R''\nσ₁₂ : R →+* R₂\nσ₂₃ : R₂ →+* R₃\nσ₁₃ : R →+* R₃\nA : Type u_6\nM : Type u_7\nN : Type u_8\nP : Type u_9... | smul_tmul', | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Module.Submodule.Finsupp | {
"line": 56,
"column": 6
} | {
"line": 56,
"column": 17
} | [
{
"pp": "case le.refine_1\nR : Type u_2\nM : Type u_3\ninst✝³ : Semiring R\ninst✝² : AddCommMonoid M\ninst✝¹ : Module R M\nsR : Set R\nN : Submodule R M\ninst✝ : SMulCommClass R R ↥N\nc : R →₀ ↥N\nhc : c ∈ ↑(Finsupp.supported (↥N) R sR)\n⊢ ∀ c_1 ∈ c.support, ↑((DistribSMul.toLinearMap R (↥N) c_1) (c c_1)) ∈ sR ... | rintro r hr | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.LinearAlgebra.TensorProduct.Defs | {
"line": 355,
"column": 25
} | {
"line": 355,
"column": 36
} | [
{
"pp": "R : Type u_1\nR₂ : Type u_2\nR₃ : Type u_3\nR' : Type u_4\nR'' : Type u_5\ninst✝⁴¹ : CommSemiring R\ninst✝⁴⁰ : CommSemiring R₂\ninst✝³⁹ : CommSemiring R₃\ninst✝³⁸ : Monoid R'\ninst✝³⁷ : Semiring R''\nσ₁₂ : R →+* R₂\nσ₂₃ : R₂ →+* R₃\nσ₁₃ : R →+* R₃\nA : Type u_6\nM : Type u_7\nN : Type u_8\nP : Type u_9... | smul_tmul', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.TensorProduct.Defs | {
"line": 355,
"column": 37
} | {
"line": 355,
"column": 48
} | [
{
"pp": "R : Type u_1\nR₂ : Type u_2\nR₃ : Type u_3\nR' : Type u_4\nR'' : Type u_5\ninst✝⁴¹ : CommSemiring R\ninst✝⁴⁰ : CommSemiring R₂\ninst✝³⁹ : CommSemiring R₃\ninst✝³⁸ : Monoid R'\ninst✝³⁷ : Semiring R''\nσ₁₂ : R →+* R₂\nσ₂₃ : R₂ →+* R₃\nσ₁₃ : R →+* R₃\nA : Type u_6\nM : Type u_7\nN : Type u_8\nP : Type u_9... | smul_tmul', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.TensorProduct.Defs | {
"line": 355,
"column": 49
} | {
"line": 355,
"column": 60
} | [
{
"pp": "R : Type u_1\nR₂ : Type u_2\nR₃ : Type u_3\nR' : Type u_4\nR'' : Type u_5\ninst✝⁴¹ : CommSemiring R\ninst✝⁴⁰ : CommSemiring R₂\ninst✝³⁹ : CommSemiring R₃\ninst✝³⁸ : Monoid R'\ninst✝³⁷ : Semiring R''\nσ₁₂ : R →+* R₂\nσ₂₃ : R₂ →+* R₃\nσ₁₃ : R →+* R₃\nA : Type u_6\nM : Type u_7\nN : Type u_8\nP : Type u_9... | smul_tmul', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Module.Submodule.Finsupp | {
"line": 115,
"column": 6
} | {
"line": 116,
"column": 70
} | [
{
"pp": "α : Type u_1\nR : Type u_2\nM : Type u_3\ninst✝⁵ : Semiring R\ninst✝⁴ : AddCommMonoid M\ninst✝³ : Module R M\nS : Type u_4\ninst✝² : Monoid S\ninst✝¹ : DistribMulAction S M\nsR : Set R\ns✝ : Set S\nN : Submodule R M\ninst✝ : SMulCommClass R R M\ns : Set R\nx y : Submodule R M\nr : R\nhr : r ∈ s\na : M\... | exact ⟨r • a, mem_set_smul_of_mem_mem (mem1 := hr) (mem2 := ha),
r • b, mem_set_smul_of_mem_mem (mem1 := hr) (mem2 := hb), rfl⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Ring.NonZeroDivisors | {
"line": 91,
"column": 27
} | {
"line": 91,
"column": 69
} | [
{
"pp": "R : Type u_1\ninst✝ : Ring R\nS : Submonoid R\n⊢ (∀ ⦃x : R⦄, x ∈ S → x ∈ nonZeroDivisorsLeft R) ↔ ∀ (s : ↥S), IsLeftRegular ↑s",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Membership.mem",
"id",
"Subtype",
"_private.Mathlib.Algebra.Ring.NonZeroDivisors.0.le_nonZer... | isLeftRegular_iff_mem_nonZeroDivisorsLeft, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Order.Kleene | {
"line": 121,
"column": 2
} | {
"line": 121,
"column": 18
} | [
{
"pp": "case succ\nα : Type u_1\ninst✝ : IdemSemiring α\nn x : ℕ\nhmn✝ : 1 ≤ x\nhx : ↑x = 1\n⊢ ↑(x + 1) = 1",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"AddMonoid.toAddSemigroup",
"congrArg",
"id",
"Distrib.toAdd",
"AddMonoidWithOne.to... | | succ x _ hx => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.RingTheory.Coprime.Basic | {
"line": 64,
"column": 14
} | {
"line": 64,
"column": 37
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nx : R\nH : IsUnit x\nb : R\nhb : b * x = 1\n⊢ 1 * 0 + b * x = 1",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"AddMonoid.toAd... | rwa [one_mul, zero_add] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.RingTheory.Coprime.Basic | {
"line": 64,
"column": 14
} | {
"line": 64,
"column": 37
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nx : R\nH : IsUnit x\nb : R\nhb : b * x = 1\n⊢ 1 * 0 + b * x = 1",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"AddMonoid.toAd... | rwa [one_mul, zero_add] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Coprime.Basic | {
"line": 64,
"column": 14
} | {
"line": 64,
"column": 37
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nx : R\nH : IsUnit x\nb : R\nhb : b * x = 1\n⊢ 1 * 0 + b * x = 1",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"AddMonoid.toAd... | rwa [one_mul, zero_add] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Coprime.Lemmas | {
"line": 130,
"column": 4
} | {
"line": 130,
"column": 52
} | [
{
"pp": "case singleton\nR : Type u\nI : Type v\ninst✝¹ : CommSemiring R\ns : I → R\nt : Finset I\ninst✝ : DecidableEq I\na✝ : I\n⊢ (∃ μ, ∑ i ∈ {a✝}, μ i * ∏ j ∈ {a✝} \\ {i}, s j = 1) ↔ Pairwise (IsCoprime on fun i ↦ s ↑i)",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.t... | simp [exists_apply_eq, Pairwise, Function.onFun] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.RingTheory.Coprime.Lemmas | {
"line": 130,
"column": 4
} | {
"line": 130,
"column": 52
} | [
{
"pp": "case singleton\nR : Type u\nI : Type v\ninst✝¹ : CommSemiring R\ns : I → R\nt : Finset I\ninst✝ : DecidableEq I\na✝ : I\n⊢ (∃ μ, ∑ i ∈ {a✝}, μ i * ∏ j ∈ {a✝} \\ {i}, s j = 1) ↔ Pairwise (IsCoprime on fun i ↦ s ↑i)",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.t... | simp [exists_apply_eq, Pairwise, Function.onFun] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Coprime.Lemmas | {
"line": 130,
"column": 4
} | {
"line": 130,
"column": 52
} | [
{
"pp": "case singleton\nR : Type u\nI : Type v\ninst✝¹ : CommSemiring R\ns : I → R\nt : Finset I\ninst✝ : DecidableEq I\na✝ : I\n⊢ (∃ μ, ∑ i ∈ {a✝}, μ i * ∏ j ∈ {a✝} \\ {i}, s j = 1) ↔ Pairwise (IsCoprime on fun i ↦ s ↑i)",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.t... | simp [exists_apply_eq, Pairwise, Function.onFun] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Ideal.Prod | {
"line": 192,
"column": 6
} | {
"line": 192,
"column": 20
} | [
{
"pp": "case mp.inl.h\nR : Type u\nS : Type v\ninst✝¹ : Semiring R\ninst✝ : Semiring S\nI : Ideal (R × S)\nhI : ((map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I)).IsPrime\nh : map (RingHom.fst R S) I = ⊤\n⊢ ∃ p, p.IsPrime ∧ (map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I) = ⊤.prod p",
"used... | rw [h] at hI ⊢ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Ideal.Prod | {
"line": 195,
"column": 6
} | {
"line": 195,
"column": 20
} | [
{
"pp": "case mp.inr.h\nR : Type u\nS : Type v\ninst✝¹ : Semiring R\ninst✝ : Semiring S\nI : Ideal (R × S)\nhI : ((map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I)).IsPrime\nh : map (RingHom.snd R S) I = ⊤\n⊢ ∃ p, p.IsPrime ∧ (map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I) = p.prod ⊤",
"used... | rw [h] at hI ⊢ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Algebra.Operations | {
"line": 868,
"column": 34
} | {
"line": 868,
"column": 67
} | [
{
"pp": "R : Type u\ninst✝² : CommSemiring R\nA : Type v\ninst✝¹ : CommSemiring A\ninst✝ : Algebra R A\nx : A\nI J : Submodule R A\nh : x ∈ I / J\ny : A\nx✝ : y ∈ x • ↑J\ny' : A\nhy' : y' ∈ ↑J\nxy'_eq_y : (fun x_1 ↦ x • x_1) y' = y\n⊢ y ∈ ↑I",
"usedConstants": [
"Eq.mpr",
"Submodule",
"ins... | by rw [← xy'_eq_y]; exact h _ hy' | [anonymous] | Lean.Parser.Term.byTactic |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.