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.GroupTheory.Finiteness | {
"line": 227,
"column": 2
} | {
"line": 228,
"column": 100
} | [
{
"pp": "M : Type u_1\ninst✝ : Monoid M\nN : Submonoid M\n⊢ FG ↥N ↔ N.FG",
"usedConstants": [
"Eq.mpr",
"MonoidHom.instMonoidHomClass",
"MonoidHom.instFunLike",
"Monoid.FG.mk",
"MonoidHom",
"Monoid.toMulOneClass",
"congrArg",
"Monoid.FG.fg_top",
"MonoidH... | conv_rhs => rw [← N.mrange_subtype, MonoidHom.mrange_eq_map]
exact ⟨fun h ↦ h.fg_top.map N.subtype, fun h => ⟨h.map_injective N.subtype Subtype.coe_injective⟩⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Commutator.Basic | {
"line": 368,
"column": 2
} | {
"line": 368,
"column": 78
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\n⊢ ⁅⁅⊤, centralizer ↑(commutator G)⁆, centralizer ↑(commutator G)⁆ = ⊥",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Subgroup.centralizer",
"PartialOrder.toPreorder",
"Bracket.bracket",
"Preorder.toLE",
"id",
"Subgroup",
... | rw [Subgroup.commutator_comm, Subgroup.commutator_eq_bot_iff_le_centralizer] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Finiteness | {
"line": 339,
"column": 42
} | {
"line": 339,
"column": 70
} | [
{
"pp": "H : Type u_4\ninst✝ : AddGroup H\nP : AddSubgroup H\n⊢ P.FG ↔ (toSubgroup P).FG",
"usedConstants": [
"Multiplicative.group",
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"AddSubgroup.instPartialOrder",
"Subgroup.fg_iff_submonoid_fg",
"Preorder.toLE",
... | Subgroup.fg_iff_submonoid_fg | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Commutator.Basic | {
"line": 383,
"column": 2
} | {
"line": 385,
"column": 35
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Group G\nH : Type u_4\ninst✝ : Group H\nf : G →* H\n⊢ ⁅map f ⊤, map f ⊤⁆ = ⁅f.range, f.range⁆",
"usedConstants": [
"Eq.mpr",
"Codisjoint",
"MonoidHom.range",
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"Subgroup.map",
"Mo... | apply congr_arg₂ <;>
· rw [Subgroup.map_eq_range_iff]
rw [codisjoint_iff, top_sup_eq] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.GroupTheory.Finiteness | {
"line": 628,
"column": 21
} | {
"line": 628,
"column": 29
} | [
{
"pp": "M : Type u_5\nN : Type u_6\ninst✝⁶ : CommMonoid M\ninst✝⁵ : PartialOrder M\ninst✝⁴ : WellQuasiOrderedLE M\ninst✝³ : IsOrderedCancelMonoid M\ninst✝² : CanonicallyOrderedMul M\ninst✝¹ : Monoid N\ninst✝ : IsCancelMul N\nf g : M →* N\n⊢ ∀ x ∈ f.eqLocusM g, ∀ (y : M), x * y ∈ f.eqLocusM g → y ∈ f.eqLocusM g... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.GroupTheory.Finiteness | {
"line": 628,
"column": 21
} | {
"line": 628,
"column": 29
} | [
{
"pp": "M : Type u_5\nN : Type u_6\ninst✝⁶ : CommMonoid M\ninst✝⁵ : PartialOrder M\ninst✝⁴ : WellQuasiOrderedLE M\ninst✝³ : IsOrderedCancelMonoid M\ninst✝² : CanonicallyOrderedMul M\ninst✝¹ : Monoid N\ninst✝ : IsCancelMul N\nf g : M →* N\n⊢ ∀ x ∈ f.eqLocusM g, ∀ (y : M), x * y ∈ f.eqLocusM g → y ∈ f.eqLocusM g... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Finiteness | {
"line": 628,
"column": 21
} | {
"line": 628,
"column": 29
} | [
{
"pp": "M : Type u_5\nN : Type u_6\ninst✝⁶ : CommMonoid M\ninst✝⁵ : PartialOrder M\ninst✝⁴ : WellQuasiOrderedLE M\ninst✝³ : IsOrderedCancelMonoid M\ninst✝² : CanonicallyOrderedMul M\ninst✝¹ : Monoid N\ninst✝ : IsCancelMul N\nf g : M →* N\n⊢ ∀ x ∈ f.eqLocusM g, ∀ (y : M), x * y ∈ f.eqLocusM g → y ∈ f.eqLocusM g... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 401,
"column": 30
} | {
"line": 401,
"column": 43
} | [
{
"pp": "α : Type u\ninst✝ : Mul α\nx y : α\n⊢ (lift fun x₁ ↦ of (x₁ * y)) (of x) = of (x * y)",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"HMul.hMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddCommGroup.toAddGroup",
"AddZeroClass.toAddZero",
"id",... | lift_apply_of | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 463,
"column": 31
} | {
"line": 463,
"column": 44
} | [
{
"pp": "α : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\nR : Type u_2\ninst✝¹ : Monoid α\ninst✝ : Ring R\nx : FreeAbelianGroup α\n⊢ (lift fun x₂ ↦ (lift fun x₁ ↦ of (x₁ * x₂)) (of 1)) x = x",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"Equiv.instEquivLike",
... | lift_apply_of | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 456,
"column": 26
} | {
"line": 456,
"column": 39
} | [
{
"pp": "α : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\nR : Type u_2\ninst✝¹ : Monoid α\ninst✝ : Ring R\nx : FreeAbelianGroup α\n⊢ (lift fun x₂ ↦ (lift fun x₁ ↦ of (x₁ * x₂)) x) (of 1) = x",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"Equiv.instEquivLike",
... | lift_apply_of | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 494,
"column": 30
} | {
"line": 494,
"column": 43
} | [
{
"pp": "case of.of\nα : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\nR : Type u_2\ninst✝¹ : Monoid α\ninst✝ : Ring R\nf : α →* R\nL2 L1 : α\n⊢ (lift ⇑f) (of (L1 * L2)) = (lift ⇑f) (of L1) * (lift ⇑f) (of L2)",
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"MonoidHom.instFunLike",
... | lift_apply_of | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 535,
"column": 22
} | {
"line": 535,
"column": 35
} | [
{
"pp": "case of.of\nα : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\ninst✝ : CommMonoid α\ns t : α\n⊢ (lift fun x₂ ↦ (lift fun x₁ ↦ of (Mul.mul x₁ x₂)) (of s)) (of t) =\n (lift fun x₂ ↦ (lift fun x₁ ↦ of (Mul.mul x₁ x₂)) (of t)) (of s)",
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
... | lift_apply_of | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 535,
"column": 22
} | {
"line": 535,
"column": 35
} | [
{
"pp": "case of.of\nα : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\ninst✝ : CommMonoid α\ns t : α\n⊢ (lift fun x₁ ↦ of (Mul.mul x₁ t)) (of s) = (lift fun x₂ ↦ (lift fun x₁ ↦ of (Mul.mul x₁ x₂)) (of t)) (of s)",
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"Equiv.instEquivLike",
... | lift_apply_of | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 535,
"column": 22
} | {
"line": 535,
"column": 35
} | [
{
"pp": "case of.of\nα : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\ninst✝ : CommMonoid α\ns t : α\n⊢ of (Mul.mul s t) = (lift fun x₂ ↦ (lift fun x₁ ↦ of (Mul.mul x₁ x₂)) (of t)) (of s)",
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"Equiv.instEquivLike",
"congrArg",
"AddM... | lift_apply_of | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 535,
"column": 22
} | {
"line": 535,
"column": 35
} | [
{
"pp": "case of.of\nα : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\ninst✝ : CommMonoid α\ns t : α\n⊢ of (Mul.mul s t) = (lift fun x₁ ↦ of (Mul.mul x₁ s)) (of t)",
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"Equiv.instEquivLike",
"congrArg",
"AddMonoid.toAddZeroClass",
... | lift_apply_of | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 554,
"column": 19
} | {
"line": 554,
"column": 32
} | [
{
"pp": "α : Type u\nG : Type u_1\nβ : Type v\nγ : Type w\nT : Type u_2\ninst✝ : Unique T\nn : ℤ\n⊢ n • (lift fun x ↦ 1) (of default) = n",
"usedConstants": [
"Int.instAddCommGroup",
"Eq.mpr",
"Inhabited.default",
"instHSMul",
"Equiv.instEquivLike",
"congrArg",
"Add... | lift_apply_of | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.OreLocalization.Basic | {
"line": 73,
"column": 51
} | {
"line": 73,
"column": 54
} | [
{
"pp": "R : Type u_1\ninst✝² : Monoid R\nS : Submonoid R\ninst✝¹ : OreSet S\nX : Type ?u.117\ninst✝ : MulAction R X\nr : X\ns : ↥S\nr' : X\ns' u : ↥S\nv : R\nhru : u • r' = v • r\nhsu : ↑u * ↑s' = v * ↑s\nr₂ : R\ns₂ : ↥S\nh₁ : ↑s₂ * ↑s = r₂ * ↑s'\nr₃ : R\ns₃ : ↥S\nh₂ : ↑s₃ * r₂ = r₃ * ↑u\n⊢ r₃ * v * ↑s = ↑s₃ *... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.MonoidLocalization.Basic | {
"line": 195,
"column": 87
} | {
"line": 202,
"column": 89
} | [
{
"pp": "M : Type u_1\ninst✝ : CommMonoid M\nS : Submonoid M\nx y : M × ↥S\n⊢ (r S) x y ↔ (OreLocalization.oreEqv S M) x y",
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"instHSMul",
"Submonoid.mul",
"HMul.hMul",
"CommMonoid.toCommSemigroup",
"Localization.r",
... | by
simp +instances only [r_iff_exists, Subtype.exists, exists_prop, OreLocalization.oreEqv,
smul_eq_mul, Submonoid.mk_smul]
constructor
· rintro ⟨u, hu, e⟩
exact ⟨_, mul_mem hu x.2.2, u * y.2, by rw [mul_assoc, mul_assoc, ← e], mul_right_comm _ _ _⟩
· rintro ⟨u, hu, v, e₁, e₂⟩
exact ⟨u, hu, by rw [←... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Iterate | {
"line": 130,
"column": 4
} | {
"line": 130,
"column": 28
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\nf : α → α\nh : id ≤ f\nn : ℕ\nx : α\n⊢ f^[n] x ≤ f^[n + 1] x",
"usedConstants": [
"Function.iterate_succ_apply'",
"Eq.mpr",
"congrArg",
"Preorder.toLE",
"id",
"instOfNatNat",
"LE.le",
"Nat.iterate",
"instHAdd",
... | rw [iterate_succ_apply'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.Iterate | {
"line": 157,
"column": 12
} | {
"line": 157,
"column": 36
} | [
{
"pp": "case hx\nα : Type u_1\ninst✝ : Preorder α\nf g : α → α\nh : Commute f g\nhf : Monotone f\nhg : Monotone g\nx : α\nhx : f x ≤ g x\nn k✝ : ℕ\na✝ : k✝ < n\n⊢ f^[k✝ + 1] x ≤ f (f^[k✝] x)",
"usedConstants": [
"Function.iterate_succ_apply'",
"Eq.mpr",
"le_refl",
"congrArg",
... | rw [iterate_succ_apply'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.Iterate | {
"line": 164,
"column": 12
} | {
"line": 164,
"column": 36
} | [
{
"pp": "case hx\nα : Type u_1\ninst✝ : Preorder α\nf g : α → α\nh : Commute f g\nhf : Monotone f\nhg : StrictMono g\nx : α\nhx : f x < g x\nn : ℕ\nhn : 0 < n\nk✝ : ℕ\na✝ : k✝ < n\n⊢ f^[k✝ + 1] x ≤ f (f^[k✝] x)",
"usedConstants": [
"Function.iterate_succ_apply'",
"Eq.mpr",
"le_refl",
... | rw [iterate_succ_apply'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 308,
"column": 52
} | {
"line": 308,
"column": 75
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : MulZeroClass α\na : WithBot α\nh : a ≠ 0\n⊢ a * ⊥ = ⊥",
"usedConstants": [
"WithBot.mul_bot'",
"Eq.mpr",
"WithBot",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"WithBot.instMulZeroClass",
"WithBot.zero"... | rw [mul_bot', if_neg h] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 308,
"column": 52
} | {
"line": 308,
"column": 75
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : MulZeroClass α\na : WithBot α\nh : a ≠ 0\n⊢ a * ⊥ = ⊥",
"usedConstants": [
"WithBot.mul_bot'",
"Eq.mpr",
"WithBot",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"WithBot.instMulZeroClass",
"WithBot.zero"... | rw [mul_bot', if_neg h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 308,
"column": 52
} | {
"line": 308,
"column": 75
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : MulZeroClass α\na : WithBot α\nh : a ≠ 0\n⊢ a * ⊥ = ⊥",
"usedConstants": [
"WithBot.mul_bot'",
"Eq.mpr",
"WithBot",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"WithBot.instMulZeroClass",
"WithBot.zero"... | rw [mul_bot', if_neg h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 410,
"column": 4
} | {
"line": 410,
"column": 31
} | [
{
"pp": "α : Type u_1\ninst✝³ : DecidableEq α\ninst✝² : MulZeroClass α\ninst✝¹ : Preorder α\ninst✝ : PosMulStrictMono α\nx : WithBot α\nx0 : 0 < x\na b : WithBot α\nh : a < b\n⊢ x * a < x * b",
"usedConstants": [
"WithBot.instPreorder",
"WithBot.some",
"WithBot",
"WithBot.instOrderBo... | lift x to α using x0.ne_bot | Mathlib.Tactic._aux_Mathlib_Tactic_Lift___elabRules_Mathlib_Tactic_lift_1 | Mathlib.Tactic.lift |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 421,
"column": 4
} | {
"line": 421,
"column": 31
} | [
{
"pp": "α : Type u_1\ninst✝³ : DecidableEq α\ninst✝² : MulZeroClass α\ninst✝¹ : Preorder α\ninst✝ : MulPosStrictMono α\nx : WithBot α\nx0 : 0 < x\na b : WithBot α\nh : a < b\n⊢ a * x < b * x",
"usedConstants": [
"WithBot.instPreorder",
"WithBot.some",
"WithBot",
"WithBot.instOrderBo... | lift x to α using x0.ne_bot | Mathlib.Tactic._aux_Mathlib_Tactic_Lift___elabRules_Mathlib_Tactic_lift_1 | Mathlib.Tactic.lift |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 470,
"column": 4
} | {
"line": 470,
"column": 31
} | [
{
"pp": "α : Type u_1\ninst✝³ : DecidableEq α\ninst✝² : MulZeroClass α\ninst✝¹ : Preorder α\ninst✝ : PosMulReflectLE α\nx : WithBot α\nx0 : 0 < x\na b : WithBot α\nh : x * a ≤ x * b\n⊢ a ≤ b",
"usedConstants": [
"WithBot.instPreorder",
"WithBot.some",
"WithBot",
"WithBot.instOrderBot... | lift x to α using x0.ne_bot | Mathlib.Tactic._aux_Mathlib_Tactic_Lift___elabRules_Mathlib_Tactic_lift_1 | Mathlib.Tactic.lift |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 484,
"column": 4
} | {
"line": 484,
"column": 31
} | [
{
"pp": "α : Type u_1\ninst✝³ : DecidableEq α\ninst✝² : MulZeroClass α\ninst✝¹ : Preorder α\ninst✝ : MulPosReflectLE α\nx : WithBot α\nx0 : 0 < x\na b : WithBot α\nh : a * x ≤ b * x\n⊢ a ≤ b",
"usedConstants": [
"WithBot.instPreorder",
"WithBot.some",
"WithBot",
"WithBot.instOrderBot... | lift x to α using x0.ne_bot | Mathlib.Tactic._aux_Mathlib_Tactic_Lift___elabRules_Mathlib_Tactic_lift_1 | Mathlib.Tactic.lift |
Mathlib.Order.SuccPred.Basic | {
"line": 435,
"column": 31
} | {
"line": 436,
"column": 63
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\ninst✝ : SuccOrder α\na b : α\nha : ¬IsMax a\nhb : ¬IsMax b\n⊢ succ a ≤ succ b ↔ a ≤ b",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Order.succ",
"congrArg",
"Iff.rfl",
"PartialOrder.toPreorder",
"Preorder.toLE",
... | by
rw [succ_le_iff_of_not_isMax ha, lt_succ_iff_of_not_isMax hb] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.SuccPred.Archimedean | {
"line": 329,
"column": 14
} | {
"line": 329,
"column": 22
} | [
{
"pp": "case h.zero\nα : Type u_1\nβ : Type u_2\ninst✝³ : PartialOrder α\ninst✝² : PredOrder α\ninst✝¹ : IsPredArchimedean α\ns : Set α\ninst✝ : s.OrdConnected\nx✝¹ x✝ : ↑s\nb : α\nhb : b ∈ s\nc : α\nhc : c ∈ s\nhbc : b ≤ c\nhn : pred^[0] c = b\n⊢ pred^[0] ⟨c, hc⟩ = ⟨b, hb⟩",
"usedConstants": [
"Subt... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Order.SuccPred.Archimedean | {
"line": 329,
"column": 14
} | {
"line": 329,
"column": 22
} | [
{
"pp": "case h.zero\nα : Type u_1\nβ : Type u_2\ninst✝³ : PartialOrder α\ninst✝² : PredOrder α\ninst✝¹ : IsPredArchimedean α\ns : Set α\ninst✝ : s.OrdConnected\nx✝¹ x✝ : ↑s\nb : α\nhb : b ∈ s\nc : α\nhc : c ∈ s\nhbc : b ≤ c\nhn : pred^[0] c = b\n⊢ pred^[0] ⟨c, hc⟩ = ⟨b, hb⟩",
"usedConstants": [
"Subt... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.SuccPred.Archimedean | {
"line": 329,
"column": 14
} | {
"line": 329,
"column": 22
} | [
{
"pp": "case h.zero\nα : Type u_1\nβ : Type u_2\ninst✝³ : PartialOrder α\ninst✝² : PredOrder α\ninst✝¹ : IsPredArchimedean α\ns : Set α\ninst✝ : s.OrdConnected\nx✝¹ x✝ : ↑s\nb : α\nhb : b ∈ s\nc : α\nhc : c ∈ s\nhbc : b ≤ c\nhn : pred^[0] c = b\n⊢ pred^[0] ⟨c, hc⟩ = ⟨b, hb⟩",
"usedConstants": [
"Subt... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.SuccPred.Basic | {
"line": 496,
"column": 2
} | {
"line": 496,
"column": 99
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\ninst✝ : SuccOrder α\na b : α\nh₁ : a < b\nh₂ : ¬IsMax b\n⊢ Ioo a (succ b) = insert b (Ioo a b)",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Order.Iio_succ_eq_insert_of_not_isMax",
"Set.Ioi",
"Preorder.toLT",
"Order.succ",
... | simp_rw [← Iio_inter_Ioi, Iio_succ_eq_insert_of_not_isMax h₂, insert_inter_of_mem (mem_Ioi.2 h₁)] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Order.SuccPred.Basic | {
"line": 496,
"column": 2
} | {
"line": 496,
"column": 99
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\ninst✝ : SuccOrder α\na b : α\nh₁ : a < b\nh₂ : ¬IsMax b\n⊢ Ioo a (succ b) = insert b (Ioo a b)",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Order.Iio_succ_eq_insert_of_not_isMax",
"Set.Ioi",
"Preorder.toLT",
"Order.succ",
... | simp_rw [← Iio_inter_Ioi, Iio_succ_eq_insert_of_not_isMax h₂, insert_inter_of_mem (mem_Ioi.2 h₁)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.SuccPred.Basic | {
"line": 496,
"column": 2
} | {
"line": 496,
"column": 99
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\ninst✝ : SuccOrder α\na b : α\nh₁ : a < b\nh₂ : ¬IsMax b\n⊢ Ioo a (succ b) = insert b (Ioo a b)",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Order.Iio_succ_eq_insert_of_not_isMax",
"Set.Ioi",
"Preorder.toLT",
"Order.succ",
... | simp_rw [← Iio_inter_Ioi, Iio_succ_eq_insert_of_not_isMax h₂, insert_inter_of_mem (mem_Ioi.2 h₁)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.SuccPred.Archimedean | {
"line": 368,
"column": 4
} | {
"line": 368,
"column": 45
} | [
{
"pp": "case succ\nα : Type u_3\nβ : Type u_4\ninst✝³ : PartialOrder α\ninst✝² : Preorder β\ninst✝¹ : SuccOrder α\ninst✝ : IsSuccArchimedean α\ns : Set α\nf : α → β\nhs : s.OrdConnected\nhf : ∀ (a : α), ¬IsMax a → a ∈ s → succ a ∈ s → f a ≤ f (succ a)\na : α\nha : a ∈ s\nn : ℕ\nhn : succ^[n] a ∈ s → f a ≤ f (s... | rw [Function.iterate_succ_apply'] at hb ⊢ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.SuccPred.Archimedean | {
"line": 389,
"column": 4
} | {
"line": 389,
"column": 45
} | [
{
"pp": "case succ.succ\nα : Type u_3\nβ : Type u_4\ninst✝³ : PartialOrder α\ninst✝² : Preorder β\ninst✝¹ : SuccOrder α\ninst✝ : IsSuccArchimedean α\ns : Set α\nf : α → β\nhs : s.OrdConnected\nhf : ∀ (a : α), ¬IsMax a → a ∈ s → succ a ∈ s → f a < f (succ a)\na : α\nha : a ∈ s\nhab : ¬IsMax a\nn : ℕ\nhn : succ^[... | rw [Function.iterate_succ_apply'] at hb ⊢ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Logic.Small.Basic | {
"line": 52,
"column": 4
} | {
"line": 53,
"column": 18
} | [
{
"pp": "case neg\nα : Type v\nβ : Type w\nγ : Type v'\ninst✝ : Small.{u, v} α\nf : α → γ\ng : β → γ\nhg : Function.Injective g\nh : ∀ (b : β), ∃ a, f a = g b\nhβ : ¬Nonempty β\n⊢ Small.{u, w} β",
"usedConstants": [
"small_subsingleton",
"_private.Mathlib.Logic.Small.Basic.0.small_of_injective_o... | simp only [not_nonempty_iff] at hβ
infer_instance | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Logic.Small.Basic | {
"line": 52,
"column": 4
} | {
"line": 53,
"column": 18
} | [
{
"pp": "case neg\nα : Type v\nβ : Type w\nγ : Type v'\ninst✝ : Small.{u, v} α\nf : α → γ\ng : β → γ\nhg : Function.Injective g\nh : ∀ (b : β), ∃ a, f a = g b\nhβ : ¬Nonempty β\n⊢ Small.{u, w} β",
"usedConstants": [
"small_subsingleton",
"_private.Mathlib.Logic.Small.Basic.0.small_of_injective_o... | simp only [not_nonempty_iff] at hβ
infer_instance | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.SuccPred.Basic | {
"line": 860,
"column": 4
} | {
"line": 862,
"column": 17
} | [
{
"pp": "case pos\nα✝ : Type u_1\nβ : Type u_2\nα : Type u_3\ninst✝² : PartialOrder α\ns : Set α\ninst✝¹ : s.OrdConnected\ninst✝ : PredOrder α\nx✝ : ↑s\nx : α\nhx : x ∈ s\nh' : pred x ∈ s\nh : ⟨x, hx⟩ ≤ ⟨pred x, h'⟩\n⊢ IsMin ⟨x, hx⟩",
"usedConstants": [
"Order.le_pred_iff_isMin._simp_1",
"Partia... | · simp only [Subtype.mk_le_mk, Order.le_pred_iff_isMin] at h
rintro ⟨y, _⟩ hy
simp [h hy] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.ENat.Basic | {
"line": 254,
"column": 21
} | {
"line": 254,
"column": 31
} | [
{
"pp": "case top\nn : ℕ\n⊢ ⊤.toNat = ⊤.toNat - (↑n).toNat",
"usedConstants": [
"Eq.mpr",
"ENat.instNatCast",
"instTopENat",
"congrArg",
"HSub.hSub",
"id",
"instSubNat",
"instOfNatNat",
"Nat.cast",
"instHSub",
"Nat",
"ENat",
"ENat... | toNat_top, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.ENat.Basic | {
"line": 294,
"column": 45
} | {
"line": 294,
"column": 53
} | [
{
"pp": "case inl\nn : ℕ∞\nh✝ : n = 0\n⊢ n ≤ 1",
"usedConstants": [
"instAddMonoidWithOneENat",
"congrArg",
"CommSemiring.toSemiring",
"instIsBotZeroClass",
"zero_le._simp_1",
"AddMonoid.toAddZeroClass",
"LE.le",
"instLEENat",
"AddMonoidWithOne.toOne",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.ENat.Basic | {
"line": 294,
"column": 45
} | {
"line": 294,
"column": 53
} | [
{
"pp": "case inr\nn : ℕ∞\nh✝ : n = 1\n⊢ n ≤ 1",
"usedConstants": [
"instAddMonoidWithOneENat",
"instReflLe",
"congrArg",
"Std.le_refl._simp_1",
"instPreorderENat",
"LE.le",
"instLEENat",
"AddMonoidWithOne.toOne",
"ENat",
"True",
"of_eq_true"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Order.SuccPred.Limit | {
"line": 246,
"column": 92
} | {
"line": 247,
"column": 73
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\nx : α\nh : IsPredLimit x\n⊢ IsPredLimit ↑x",
"usedConstants": [
"Eq.mpr",
"False",
"Preorder.toLT",
"WithTop.instPreorder",
"congrArg",
"true_or",
"WithTop.coe_ne_top._simp_1",
"Preorder.toLE",
"Exists",
"... | by
simpa [WithTop.isPredPrelimit_iff, IsPredLimit, WithTop.exists] using h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.SuccPred.Limit | {
"line": 380,
"column": 2
} | {
"line": 383,
"column": 27
} | [
{
"pp": "case neg\nα : Type u_1\na b : α\ninst✝¹ : PartialOrder α\ninst✝ : SuccOrder α\nhb : IsSuccPrelimit b\nha : a < b\nh : ¬IsMax a\n⊢ succ a < b",
"usedConstants": [
"lt_iff_le_and_ne",
"Eq.mpr",
"False",
"Preorder.toLT",
"Order.succ",
"Order.IsSuccPrelimit",
"... | · rw [lt_iff_le_and_ne, succ_le_iff_of_not_isMax h]
refine ⟨ha, fun hab => ?_⟩
subst hab
exact (h hb.isMax).elim | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Vector.Defs | {
"line": 255,
"column": 27
} | {
"line": 255,
"column": 35
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nσ : Type u_3\nφ : Type u_4\nn : ℕ\np : α → Prop\nv : Vector α n\ni : ℕ\nhi : i < v.toList.length\n⊢ i < n",
"usedConstants": [
"congrArg",
"Eq.mp",
"id",
"List.Vector.toList_length",
"Nat",
"LT.lt",
"instLTNat",
"List.lengt... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Vector.Defs | {
"line": 255,
"column": 27
} | {
"line": 255,
"column": 35
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nσ : Type u_3\nφ : Type u_4\nn : ℕ\np : α → Prop\nv : Vector α n\ni : ℕ\nhi : i < v.toList.length\n⊢ i < n",
"usedConstants": [
"congrArg",
"Eq.mp",
"id",
"List.Vector.toList_length",
"Nat",
"LT.lt",
"instLTNat",
"List.lengt... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Vector.Defs | {
"line": 255,
"column": 27
} | {
"line": 255,
"column": 35
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nσ : Type u_3\nφ : Type u_4\nn : ℕ\np : α → Prop\nv : Vector α n\ni : ℕ\nhi : i < v.toList.length\n⊢ i < n",
"usedConstants": [
"congrArg",
"Eq.mp",
"id",
"List.Vector.toList_length",
"Nat",
"LT.lt",
"instLTNat",
"List.lengt... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | {
"line": 202,
"column": 42
} | {
"line": 202,
"column": 50
} | [
{
"pp": "ι : Type u_1\nM : Type u_3\ninst✝¹ : CommMonoid M\ninst✝ : DecidableEq ι\ns : Finset ι\ni : ι\nh : i ∈ s\nf : ι → M\n⊢ i ∉ s → f i = 1",
"usedConstants": [
"MulOne.toOne",
"False",
"Monoid.toMulOneClass",
"congrArg",
"Finset",
"Membership.mem",
"not_true_eq... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | {
"line": 202,
"column": 42
} | {
"line": 202,
"column": 50
} | [
{
"pp": "ι : Type u_1\nM : Type u_3\ninst✝¹ : CommMonoid M\ninst✝ : DecidableEq ι\ns : Finset ι\ni : ι\nh : i ∈ s\nf : ι → M\n⊢ i ∉ s → f i = 1",
"usedConstants": [
"MulOne.toOne",
"False",
"Monoid.toMulOneClass",
"congrArg",
"Finset",
"Membership.mem",
"not_true_eq... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | {
"line": 202,
"column": 42
} | {
"line": 202,
"column": 50
} | [
{
"pp": "ι : Type u_1\nM : Type u_3\ninst✝¹ : CommMonoid M\ninst✝ : DecidableEq ι\ns : Finset ι\ni : ι\nh : i ∈ s\nf : ι → M\n⊢ i ∉ s → f i = 1",
"usedConstants": [
"MulOne.toOne",
"False",
"Monoid.toMulOneClass",
"congrArg",
"Finset",
"Membership.mem",
"not_true_eq... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Vector.Basic | {
"line": 108,
"column": 19
} | {
"line": 108,
"column": 29
} | [
{
"pp": "α : Type u_1\nn : ℕ\nβ : Type u_6\nv : Vector α (n + 1)\nf : α → β\na : α\nv' : Vector α n\nh : v = a ::ᵥ v'\n⊢ (f a ::ᵥ map f v').tail = map f (a ::ᵥ v').tail",
"usedConstants": [
"Eq.mpr",
"List.Vector.tail_cons",
"congrArg",
"List.Vector.map",
"List.Vector",
"... | tail_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Vector.Basic | {
"line": 556,
"column": 4
} | {
"line": 556,
"column": 61
} | [
{
"pp": "α : Type u_1\nn : ℕ\na : α\nv : Vector α (n + 1)\ni : ℕ\nhi : i < n + 1\nj : ℕ\nhj : j < n + 2\n⊢ eraseIdx (⟨j, hj⟩.succAbove ⟨i, hi⟩) (insertIdx a ⟨j, hj⟩ v) =\n insertIdx a (⟨i, hi⟩.predAbove ⟨j, hj⟩) (eraseIdx ⟨i, hi⟩ v)",
"usedConstants": [
"Fin.succAbove",
"List.Vector",
"... | dsimp [insertIdx, eraseIdx, Fin.succAbove, Fin.predAbove] | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.Data.Vector.Basic | {
"line": 615,
"column": 2
} | {
"line": 615,
"column": 10
} | [
{
"pp": "α : Type u_1\nn : ℕ\ninst✝ : Monoid α\nv : Vector α n\ni : Fin n\na : α\n⊢ ((List.take (↑i) v.toList).prod * if ↑i < v.toList.length then a else 1) * (List.drop (↑i + 1) v.toList).prod =\n (take (↑i) v).toList.prod * a * (drop (↑i + 1) v).toList.prod",
"usedConstants": [
"MulOne.toOne",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Vector.Basic | {
"line": 751,
"column": 4
} | {
"line": 751,
"column": 27
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type u_2\nγ : Type u_3\nn : ℕ\nf : α → β → γ\nn✝ : ℕ\na✝ : α\nb✝ : β\nx✝ : Vector α n✝\ny✝ : Vector β n✝\nih : ∀ (i : Fin n✝), (map₂ f x✝ y✝).get i = f (x✝.get i) (y✝.get i)\ni : Fin n✝.succ\n⊢ (f a✝ b✝ ::ᵥ map₂ f x✝ y✝).get i = f ((a✝ ::ᵥ x✝).get i) ((b✝ ::ᵥ y✝).get i)",
... | cases i using Fin.cases | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Order.SuccPred.CompleteLinearOrder | {
"line": 93,
"column": 2
} | {
"line": 93,
"column": 23
} | [
{
"pp": "α : Type u_2\ninst✝ : ConditionallyCompleteLinearOrderBot α\ns : Set α\nhne : s.Nonempty\nhbbd : BddAbove s\nhlim : sSup s = ⊥ ∨ ¬IsSuccPrelimit (sSup s)\nh : sSup s = ⊥\n⊢ sSup s ∈ s",
"usedConstants": []
}
] | obtain ⟨a, ha⟩ := hne | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Sum.Order | {
"line": 375,
"column": 6
} | {
"line": 383,
"column": 27
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝¹ : Preorder α\ninst✝ : Preorder β\na b : _root_.Lex (α ⊕ β)\n⊢ a < b ↔ a ≤ b ∧ ¬b ≤ a",
"usedConstants": [
"LE.le.lt_of_not_ge",
"False",
"Sum.Lex.LE",
"Preorder.toLT",
"Equiv.instEquivLike",
"HEq.refl",
"Lex"... | refine ⟨fun hab => ⟨hab.mono (fun _ _ => le_of_lt) fun _ _ => le_of_lt, ?_⟩, ?_⟩
· rintro (⟨hba⟩ | ⟨hba⟩ | ⟨b, a⟩)
· exact hba.not_gt (inl_lt_inl_iff.1 hab)
· exact hba.not_gt (inr_lt_inr_iff.1 hab)
· exact not_inr_lt_inl hab
· rintro ⟨⟨hab⟩ | ⟨hab⟩ | ⟨a, b⟩, hba⟩
· exact Lex... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Sum.Order | {
"line": 375,
"column": 6
} | {
"line": 383,
"column": 27
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝¹ : Preorder α\ninst✝ : Preorder β\na b : _root_.Lex (α ⊕ β)\n⊢ a < b ↔ a ≤ b ∧ ¬b ≤ a",
"usedConstants": [
"LE.le.lt_of_not_ge",
"False",
"Sum.Lex.LE",
"Preorder.toLT",
"Equiv.instEquivLike",
"HEq.refl",
"Lex"... | refine ⟨fun hab => ⟨hab.mono (fun _ _ => le_of_lt) fun _ _ => le_of_lt, ?_⟩, ?_⟩
· rintro (⟨hba⟩ | ⟨hba⟩ | ⟨b, a⟩)
· exact hba.not_gt (inl_lt_inl_iff.1 hab)
· exact hba.not_gt (inr_lt_inr_iff.1 hab)
· exact not_inr_lt_inl hab
· rintro ⟨⟨hab⟩ | ⟨hab⟩ | ⟨a, b⟩, hba⟩
· exact Lex... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sum.Order | {
"line": 747,
"column": 4
} | {
"line": 748,
"column": 28
} | [
{
"pp": "case coe.bot\nα : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝ : LE α\na✝ : α\n⊢ Sum.Lex (fun x1 x2 ↦ True) (fun x1 x2 ↦ x1 ≤ x2)\n (Sum.elim inr inl\n (match ↑a✝, inr PUnit.unit, inl with\n | Option.some x, x_1, f => f x\n | none, y, x => y))\n (Sum.elim inr inl\n ... | · simp only [elim_inl, elim_inr, lex_inr_inl, false_iff]
exact not_coe_le_bot _ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Part | {
"line": 267,
"column": 2
} | {
"line": 267,
"column": 17
} | [
{
"pp": "α : Type u_1\no : Part α\ninst✝ : Decidable o.Dom\na : α\n⊢ a ∈ o.toOption ↔ a ∈ o",
"usedConstants": [
"Part",
"Option.instMembership",
"Membership.mem",
"id",
"Part.instMembership",
"Iff",
"Part.toOption",
"Option"
]
}
] | unfold toOption | Lean.Elab.Tactic.evalUnfold | Lean.Parser.Tactic.unfold |
Mathlib.Data.Part | {
"line": 419,
"column": 2
} | {
"line": 419,
"column": 10
} | [
{
"pp": "case H\nα : Type u_1\np : Prop\nf : p → Part α\nh : p\na✝ : α\n⊢ a✝ ∈ assert p f ↔ a✝ ∈ f h",
"usedConstants": [
"Iff.mpr",
"Part",
"Iff.of_eq",
"congrArg",
"Membership.mem",
"Exists",
"Part.instMembership",
"Part.mem_assert_iff._simp_1",
"iff_s... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Part | {
"line": 423,
"column": 2
} | {
"line": 423,
"column": 10
} | [
{
"pp": "case H\nα : Type u_1\np : Prop\nf : p → Part α\nh : ¬p\na✝ : α\n⊢ a✝ ∈ assert p f ↔ a✝ ∈ none",
"usedConstants": [
"Iff.mpr",
"Part",
"False",
"eq_false",
"Iff.of_eq",
"congrArg",
"Part.notMem_none._simp_1",
"Membership.mem",
"Exists",
"Pa... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Part | {
"line": 512,
"column": 72
} | {
"line": 513,
"column": 48
} | [
{
"pp": "α : Type u_1\nf : α → α\nH : ∀ (x : α), f x = x\no : Part α\n⊢ map f o = o",
"usedConstants": [
"Part",
"Eq.mpr",
"congrArg",
"Monad.toApplicative",
"LawfulApplicative.toLawfulFunctor",
"id",
"funext",
"Part.instLawfulMonad",
"Applicative.toFunc... | by
rw [show f = id from funext H]; exact id_map o | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.BourbakiWitt | {
"line": 135,
"column": 2
} | {
"line": 154,
"column": 44
} | [
{
"pp": "α : Type u_1\ninst✝ : ChainCompletePartialOrder α\nx : α\nf : α → α\ny : α\nle_map : ∀ (x : α), x ≤ f x\nhy : IsExtremePt x f y\n⊢ IsAdmissible x f {z | z ∈ bot x f ∧ (z ≤ y ∨ f y ≤ z)}",
"usedConstants": [
"Mathlib.Tactic.Push.not_forall_eq",
"le_refl",
"Preorder.toLT",
"lo... | · apply IsAdmissible.mk
· constructor
· constructor
· exact (bot_isAdmissible le_map).base_isLeast.1
· exact Or.inl ((bot_isAdmissible le_map).base_isLeast.2 hy.mem_bot)
· exact fun y h ↦ (bot_isAdmissible le_map).base_isLeast.2 h.1
· rintro _ ⟨z, ⟨hz, (hzy | hyz)⟩, rfl⟩ <;>
... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.BourbakiWitt | {
"line": 211,
"column": 10
} | {
"line": 211,
"column": 38
} | [
{
"pp": "case inr.h\nα : Type u_1\ninst✝ : ChainCompletePartialOrder α\nx : α\nf : α → α\nle_map : ∀ (x : α), x ≤ f x\ny : α\nhy : IsExtremePt x f y\nz : α\na✝ : y ≠ z\nleft✝ : z ∈ bot x f\nhz : f y ≤ z\n⊢ (fun x1 x2 ↦ x1 ≤ x2) y z",
"usedConstants": [
"PartialOrder.toPreorder",
"ChainCompletePa... | exact le_trans (le_map y) hz | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.Cardinal.SchroederBernstein | {
"line": 64,
"column": 46
} | {
"line": 64,
"column": 52
} | [
{
"pp": "α : Type u\nβ : Type v\nf : α → β\ng : β → α\nhf : Injective f\nhg : Injective g\nR : α → β → Prop\nhp₁ : ∀ (a : α), R a (f a)\nhp₂ : ∀ (b : β), R (g b) b\nhβ : Nonempty β\nF : Set α →o Set α := { toFun := fun s ↦ (g '' (f '' s)ᶜ)ᶜ, monotone' := ⋯ }\ns : Set α := OrderHom.lfp F\nhs : (g '' (f '' s)ᶜ)ᶜ ... | ← hns, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.OmegaCompletePartialOrder | {
"line": 564,
"column": 4
} | {
"line": 564,
"column": 21
} | [
{
"pp": "case a\nα : Type u_2\ninst✝ : OmegaCompletePartialOrder α\nβ γ : Type v\nc : Chain α\nf : α →o Part β\ng : α →o β → Part γ\nx : Part γ\nh''' : ∀ (i : ℕ), (c.map (f.partBind g)) i ≤ x\nb : β\ni : ℕ\ny : γ\nj : ℕ\nhb : b ∈ f (c (max i j))\nhy : y ∈ g (c (max i j)) b\n⊢ ∃ a ∈ f (c (max i j)), y ∈ g (c (ma... | exact ⟨_, hb, hy⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.Cardinal.ENat | {
"line": 154,
"column": 2
} | {
"line": 154,
"column": 33
} | [
{
"pp": "case inr\nhx : ℵ₀ ≤ ℵ₀\n⊢ ℵ₀ ∈ range ofENat",
"usedConstants": [
"Set.mem_range_self",
"Cardinal",
"instTopENat",
"Cardinal.ofENat",
"ENat",
"Top.top"
]
}
] | · exact mem_range_self (⊤ : ℕ∞) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.SetTheory.Cardinal.ENat | {
"line": 261,
"column": 25
} | {
"line": 261,
"column": 59
} | [
{
"pp": "c' : Cardinal.{u}\nc : ℕ∞\n⊢ toENat ↑c ≤ toENat c' ↔ ↑c ≤ c'",
"usedConstants": [
"Eq.mpr",
"Cardinal.toENat_ofENat",
"Cardinal",
"congrArg",
"CommSemiring.toSemiring",
"Cardinal.commSemiring",
"PartialOrder.toPreorder",
"OrderRingHom.instFunLike",
... | simp_rw [toENat_ofENat, enat_gc _] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Logic.Function.CompTypeclasses | {
"line": 66,
"column": 21
} | {
"line": 67,
"column": 39
} | [
{
"pp": "M : Type u_1\nN : Type u_2\nP : Type u_3\nφ : M → N\nψ : N → P\nχ : M → P\nh : CompTriple φ ψ χ\nx : M\n⊢ ψ (φ x) = χ x",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Function.comp",
"id",
"CompTriple.comp_eq",
"Eq.refl",
"Function.comp_apply",
"Eq.symm"... | by
rw [← h.comp_eq, Function.comp_apply] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Cardinal.Basic | {
"line": 220,
"column": 4
} | {
"line": 220,
"column": 25
} | [
{
"pp": "s : Set Cardinal.{u_1}\nhs : BddAbove s\n⊢ lift.{u, u_1} (sSup s) ∈ upperBounds (lift.{u, u_1} '' s)",
"usedConstants": [
"Cardinal"
]
}
] | rintro i ⟨j, hj, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.SetTheory.Cardinal.Basic | {
"line": 320,
"column": 67
} | {
"line": 321,
"column": 31
} | [
{
"pp": "c : Cardinal.{u_1}\n⊢ 1 ≤ c ↔ 0 < c",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Cardinal.instOne",
"Order.succ",
"Cardinal",
"congrArg",
"Iff.rfl",
"PartialOrder.toPreorder",
"Cardinal.instNoMaxOrder",
"Preorder.toLE",
"Cardinal... | by
rw [← succ_zero, succ_le_iff] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Cardinal.Basic | {
"line": 1025,
"column": 6
} | {
"line": 1025,
"column": 22
} | [
{
"pp": "b c a : Cardinal.{u}\nh : c < b\n⊢ BddAbove (range fun y ↦ a ^ ↑y)",
"usedConstants": [
"Eq.mpr",
"Cardinal.instPowCardinal",
"Cardinal",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Set.Elem",
"id",
"Conditio... | ← image_eq_range | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Cardinal.Basic | {
"line": 1031,
"column": 8
} | {
"line": 1031,
"column": 24
} | [
{
"pp": "case h\na b c : Cardinal.{u}\n⊢ BddAbove (range fun c ↦ a ^ ↑c)",
"usedConstants": [
"Eq.mpr",
"Cardinal.instPowCardinal",
"Cardinal",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Set.Elem",
"id",
"Conditional... | ← image_eq_range | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Algebra.Defs | {
"line": 238,
"column": 63
} | {
"line": 238,
"column": 66
} | [
{
"pp": "R : Type u\nS : Type v\nA : Type w\nB : Type u_1\ninst✝² : CommSemiring R\ninst✝¹ : Semiring A\ninst✝ : Module R A\nh₁ : ∀ (r : R) (x y : A), r • x * y = r • (x * y)\nh₂ : ∀ (r : R) (x y : A), x * r • y = r • (x * y)\nr : R\nx : A\n⊢ x * r • 1 = r • x",
"usedConstants": [
"Eq.mpr",
"Non... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Module.Torsion.Free | {
"line": 160,
"column": 33
} | {
"line": 161,
"column": 99
} | [
{
"pp": "R : Type u_1\nM : Type u_3\ninst✝³ : Ring R\ninst✝² : AddCommGroup M\ninst✝¹ : Module R M\ninst✝ : Nontrivial R\nh : ∀ (r : R) (m : M), r • m = 0 → r = 0 ∨ m = 0\nr : R\nhr : IsRegular r\nm₁ m₂ : M\nhm : (fun x ↦ r • x) m₁ = (fun x ↦ r • x) m₂\n⊢ m₁ = m₂",
"usedConstants": [
"Eq.mpr",
"... | by
simpa [sub_eq_zero, hr.ne_zero] using h r (m₁ - m₂) (by simpa [smul_sub, sub_eq_zero] using hm) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Ring.CharZero | {
"line": 53,
"column": 62
} | {
"line": 54,
"column": 44
} | [
{
"pp": "R : Type u_2\nS : Type u_3\ninst✝² : NonAssocSemiring R\ninst✝¹ : NonAssocSemiring S\nϕ : R →+* S\ninst✝ : CharZero S\na b : ℕ\nh : ↑a = ↑b\n⊢ ↑a = ↑b",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomClass",
"congrArg",
"Rin... | by
rw [← map_natCast ϕ, ← map_natCast ϕ, h] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {
"line": 206,
"column": 14
} | {
"line": 206,
"column": 43
} | [
{
"pp": "R : Type u\nS : Type v\nT : Type w\ninst✝ : NonUnitalNonAssocSemiring R\ns : Set R\nsg : Subsemigroup R\nhg : ↑sg = s\nsa : AddSubmonoid R\nha : ↑sa = s\n⊢ ∀ {a b : R}, a ∈ s → b ∈ s → a * b ∈ s",
"usedConstants": [
"HMul.hMul",
"Subsemigroup.mul_mem",
"AddMonoid.toAddZeroClass",
... | by subst hg; exact sg.mul_mem | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {
"line": 291,
"column": 32
} | {
"line": 291,
"column": 40
} | [
{
"pp": "R : Type u\nS : Type v\nT : Type w\ninst✝ : NonUnitalNonAssocSemiring R\na✝ b✝ : R\nx✝¹ : a✝ ∈ {0}\nx✝ : b✝ ∈ {0}\n⊢ a✝ + b✝ ∈ {0}",
"usedConstants": [
"congrArg",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"Eq.mp",
"Set.instSingleton... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {
"line": 291,
"column": 32
} | {
"line": 291,
"column": 40
} | [
{
"pp": "R : Type u\nS : Type v\nT : Type w\ninst✝ : NonUnitalNonAssocSemiring R\na✝ b✝ : R\nx✝¹ : a✝ ∈ {0}\nx✝ : b✝ ∈ {0}\n⊢ a✝ + b✝ ∈ {0}",
"usedConstants": [
"congrArg",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"Eq.mp",
"Set.instSingleton... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {
"line": 291,
"column": 32
} | {
"line": 291,
"column": 40
} | [
{
"pp": "R : Type u\nS : Type v\nT : Type w\ninst✝ : NonUnitalNonAssocSemiring R\na✝ b✝ : R\nx✝¹ : a✝ ∈ {0}\nx✝ : b✝ ∈ {0}\n⊢ a✝ + b✝ ∈ {0}",
"usedConstants": [
"congrArg",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"Eq.mp",
"Set.instSingleton... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {
"line": 293,
"column": 32
} | {
"line": 293,
"column": 40
} | [
{
"pp": "R : Type u\nS : Type v\nT : Type w\ninst✝ : NonUnitalNonAssocSemiring R\na✝ b✝ : R\nx✝¹ : a✝ ∈ {0}\nx✝ : b✝ ∈ {0}\n⊢ a✝ * b✝ ∈ {0}",
"usedConstants": [
"HMul.hMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Membership.mem",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {
"line": 293,
"column": 32
} | {
"line": 293,
"column": 40
} | [
{
"pp": "R : Type u\nS : Type v\nT : Type w\ninst✝ : NonUnitalNonAssocSemiring R\na✝ b✝ : R\nx✝¹ : a✝ ∈ {0}\nx✝ : b✝ ∈ {0}\n⊢ a✝ * b✝ ∈ {0}",
"usedConstants": [
"HMul.hMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Membership.mem",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {
"line": 293,
"column": 32
} | {
"line": 293,
"column": 40
} | [
{
"pp": "R : Type u\nS : Type v\nT : Type w\ninst✝ : NonUnitalNonAssocSemiring R\na✝ b✝ : R\nx✝¹ : a✝ ∈ {0}\nx✝ : b✝ ∈ {0}\n⊢ a✝ * b✝ ∈ {0}",
"usedConstants": [
"HMul.hMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Membership.mem",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Algebra.Hom | {
"line": 504,
"column": 6
} | {
"line": 504,
"column": 38
} | [
{
"pp": "R : Type u\nA : Type v\ninst✝⁴ : CommSemiring R\ninst✝³ : Semiring A\ninst✝² : Algebra R A\nM : Submonoid R\nB : Type w\ninst✝¹ : Semiring B\ninst✝ : Algebra R B\nf : A →ₐ[R] B\n⊢ algebraMapSubmonoid A M ≤ Submonoid.comap f.toRingHom (algebraMapSubmonoid B M)",
"usedConstants": [
"Eq.mpr",
... | ← algebraMapSubmonoid_map_eq M f | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Irreducible.Lemmas | {
"line": 106,
"column": 2
} | {
"line": 106,
"column": 42
} | [
{
"pp": "M : Type u_2\ninst✝ : Monoid M\ny : M\nha : Irreducible (y ^ 2)\n⊢ False",
"usedConstants": [
"instDecidableNot",
"not_irreducible_pow",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDec... | exact not_irreducible_pow (by decide) ha | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Prime.Lemmas | {
"line": 166,
"column": 2
} | {
"line": 166,
"column": 10
} | [
{
"pp": "M : Type u_1\ninst✝¹ : CommMonoidWithZero M\ninst✝ : IsCancelMulZero M\np q : M\nhcontra : p = q\nhp : p ≠ 0\nx : M\nhx' : ¬IsUnit x\nhx'' : q = p * x\n⊢ False",
"usedConstants": [
"MulOne.toOne",
"False",
"HMul.hMul",
"eq_false",
"MulZeroClass.toMul",
"congrArg"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.NonZeroDivisors | {
"line": 82,
"column": 40
} | {
"line": 82,
"column": 48
} | [
{
"pp": "M₀ : Type u_1\ninst✝² : MonoidWithZero M₀\ninst✝¹ : NoZeroDivisors M₀\ninst✝ : Nontrivial M₀\nx : M₀\nhx : x ≠ 0\ny : M₀\nhx' : x = 0 ∨ y = 0\n⊢ y = 0",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"Eq.mp",
"id",
"false_or",
"MonoidWithZero.toMulZero... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.NonZeroDivisors | {
"line": 82,
"column": 40
} | {
"line": 82,
"column": 48
} | [
{
"pp": "M₀ : Type u_1\ninst✝² : MonoidWithZero M₀\ninst✝¹ : NoZeroDivisors M₀\ninst✝ : Nontrivial M₀\nx : M₀\nhx : x ≠ 0\ny : M₀\nhx' : x = 0 ∨ y = 0\n⊢ y = 0",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"Eq.mp",
"id",
"false_or",
"MonoidWithZero.toMulZero... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.GroupWithZero.NonZeroDivisors | {
"line": 82,
"column": 40
} | {
"line": 82,
"column": 48
} | [
{
"pp": "M₀ : Type u_1\ninst✝² : MonoidWithZero M₀\ninst✝¹ : NoZeroDivisors M₀\ninst✝ : Nontrivial M₀\nx : M₀\nhx : x ≠ 0\ny : M₀\nhx' : x = 0 ∨ y = 0\n⊢ y = 0",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"Eq.mp",
"id",
"false_or",
"MonoidWithZero.toMulZero... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GroupWithZero.NonZeroDivisors | {
"line": 84,
"column": 2
} | {
"line": 84,
"column": 34
} | [
{
"pp": "case h\nM₀ : Type u_1\ninst✝² : MonoidWithZero M₀\ninst✝¹ : NoZeroDivisors M₀\ninst✝ : Nontrivial M₀\nx : M₀\nh : x = 0\n⊢ ∃ y, (x = 0 ∨ y = 0) ∧ y ≠ 0",
"usedConstants": [
"MulOne.toOne",
"NeZero.one",
"Ne",
"MulZeroOneClass.toMulOneClass",
"MulOneClass.toMulOne",
... | exact ⟨1, Or.inl h, one_ne_zero⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.GroupWithZero.Associated | {
"line": 193,
"column": 4
} | {
"line": 193,
"column": 12
} | [
{
"pp": "case pos\nM : Type u_1\ninst✝¹ : MonoidWithZero M\ninst✝ : IsLeftCancelMulZero M\na c d : M\na_eq : a = a * c * d\nha0 : a = 0\n⊢ a ~ᵤ a * c",
"usedConstants": [
"Semigroup.toMul",
"HMul.hMul",
"congrArg",
"MulZeroClass.zero_mul",
"SemigroupWithZero.toSemigroup",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.Associated | {
"line": 193,
"column": 4
} | {
"line": 193,
"column": 12
} | [
{
"pp": "case pos\nM : Type u_1\ninst✝¹ : MonoidWithZero M\ninst✝ : IsLeftCancelMulZero M\na c d : M\na_eq : a = a * c * d\nha0 : a = 0\n⊢ a ~ᵤ a * c",
"usedConstants": [
"Semigroup.toMul",
"HMul.hMul",
"congrArg",
"MulZeroClass.zero_mul",
"SemigroupWithZero.toSemigroup",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.GroupWithZero.Associated | {
"line": 193,
"column": 4
} | {
"line": 193,
"column": 12
} | [
{
"pp": "case pos\nM : Type u_1\ninst✝¹ : MonoidWithZero M\ninst✝ : IsLeftCancelMulZero M\na c d : M\na_eq : a = a * c * d\nha0 : a = 0\n⊢ a ~ᵤ a * c",
"usedConstants": [
"Semigroup.toMul",
"HMul.hMul",
"congrArg",
"MulZeroClass.zero_mul",
"SemigroupWithZero.toSemigroup",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Ring.Subring.Basic | {
"line": 611,
"column": 19
} | {
"line": 611,
"column": 27
} | [
{
"pp": "R : Type u_1\ninst✝ : Ring R\ns : Set R\nx x✝ : R\nhx : x✝ ∈ ↑(Submonoid.closure s)\nl : List R\nhl : ∀ y ∈ l, y ∈ s\nh : l.prod = x✝\n⊢ (∀ t ∈ [l], ∀ y ∈ t, y ∈ s ∨ y = -1) ∧ (List.map List.prod [l]).sum = x✝",
"usedConstants": [
"NegZeroClass.toNeg",
"False",
"congrArg",
"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.Ring.Subring.Basic | {
"line": 611,
"column": 19
} | {
"line": 611,
"column": 27
} | [
{
"pp": "R : Type u_1\ninst✝ : Ring R\ns : Set R\nx x✝ : R\nhx : x✝ ∈ ↑(Submonoid.closure s)\nl : List R\nhl : ∀ y ∈ l, y ∈ s\nh : l.prod = x✝\n⊢ (∀ t ∈ [l], ∀ y ∈ t, y ∈ s ∨ y = -1) ∧ (List.map List.prod [l]).sum = x✝",
"usedConstants": [
"NegZeroClass.toNeg",
"False",
"congrArg",
"... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Ring.Subring.Basic | {
"line": 611,
"column": 19
} | {
"line": 611,
"column": 27
} | [
{
"pp": "R : Type u_1\ninst✝ : Ring R\ns : Set R\nx x✝ : R\nhx : x✝ ∈ ↑(Submonoid.closure s)\nl : List R\nhl : ∀ y ∈ l, y ∈ s\nh : l.prod = x✝\n⊢ (∀ t ∈ [l], ∀ y ∈ t, y ∈ s ∨ y = -1) ∧ (List.map List.prod [l]).sum = x✝",
"usedConstants": [
"NegZeroClass.toNeg",
"False",
"congrArg",
"... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GroupWithZero.NonZeroDivisors | {
"line": 318,
"column": 86
} | {
"line": 319,
"column": 55
} | [
{
"pp": "M₀ : Type u_1\ninst✝ : CommMonoidWithZero M₀\nr : M₀\n⊢ r ∉ M₀⁰ ↔ {s | r * s = 0 ∧ s ≠ 0}.Nonempty",
"usedConstants": [
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"_private.Mathlib.Algebra.GroupWithZero.NonZeroDivisors.0.notMem_nonZeroDivisors_iff_left._simp_1_1",
... | by
simp [mem_nonZeroDivisors_iff_left, Set.nonempty_def] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.GroupWithZero.Associated | {
"line": 250,
"column": 20
} | {
"line": 250,
"column": 28
} | [
{
"pp": "M : Type u_1\ninst✝¹ : CommMonoidWithZero M\ninst✝ : IsCancelMulZero M\np : M\nn : ℕ\nhp : Prime (p ^ n)\nthis : n = 1\n⊢ Prime p ∧ n = 1",
"usedConstants": [
"congrArg",
"and_self",
"Prime",
"Eq.mp",
"id",
"instOfNatNat",
"CommMonoidWithZero.toMonoidWithZe... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.Associated | {
"line": 250,
"column": 20
} | {
"line": 250,
"column": 28
} | [
{
"pp": "M : Type u_1\ninst✝¹ : CommMonoidWithZero M\ninst✝ : IsCancelMulZero M\np : M\nn : ℕ\nhp : Prime (p ^ n)\nthis : n = 1\n⊢ Prime p ∧ n = 1",
"usedConstants": [
"congrArg",
"and_self",
"Prime",
"Eq.mp",
"id",
"instOfNatNat",
"CommMonoidWithZero.toMonoidWithZe... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.