module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.Data.Int.Init | {
"line": 355,
"column": 84
} | {
"line": 355,
"column": 94
} | {
"line": 356,
"column": 0
} | [
{
"pp": "m n : ℕ\n⊢ -[m+1].gcd ↑n = (m + 1).gcd n",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Nat.gcd",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"eq_self",
"of_eq_true",
"instAddNat",
"OfNat.ofNat",
"Eq"
],
"use... | [] | simp [gcd] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.Init | {
"line": 357,
"column": 60
} | {
"line": 357,
"column": 70
} | {
"line": 359,
"column": 0
} | [
{
"pp": "m n : ℕ\n⊢ -[m+1].gcd -[n+1] = (m + 1).gcd (n + 1)",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Nat.gcd",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"eq_self",
"of_eq_true",
"instAddNat",
"OfNat.ofNat",
"Eq"
... | [] | simp [gcd] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Int.Init | {
"line": 357,
"column": 60
} | {
"line": 357,
"column": 70
} | {
"line": 359,
"column": 0
} | [
{
"pp": "m n : ℕ\n⊢ -[m+1].gcd -[n+1] = (m + 1).gcd (n + 1)",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Nat.gcd",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"eq_self",
"of_eq_true",
"instAddNat",
"OfNat.ofNat",
"Eq"
... | [] | simp [gcd] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Int.Init | {
"line": 357,
"column": 60
} | {
"line": 357,
"column": 70
} | {
"line": 359,
"column": 0
} | [
{
"pp": "m n : ℕ\n⊢ -[m+1].gcd -[n+1] = (m + 1).gcd (n + 1)",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Nat.gcd",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"eq_self",
"of_eq_true",
"instAddNat",
"OfNat.ofNat",
"Eq"
... | [] | simp [gcd] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.Function | {
"line": 1364,
"column": 4
} | {
"line": 1364,
"column": 36
} | {
"line": 1364,
"column": 37
} | [
{
"pp": "α : Type u_1\ns : Set α\ninst✝ : DecidableEq α\na b : α\nha : a ∈ s\nhb : b ∈ s\nx : α\n⊢ (swap a b) x ∈ s ↔ x ∈ s",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Equiv.instEquivLike",
"Equiv.swap",
"Membership.mem",
"Equiv",
"Ne",
"Or.casesOn"... | [
"case inl\nα : Type u_1\ns : Set α\ninst✝ : DecidableEq α\nb : α\nhb : b ∈ s\nx : α\nha : x ∈ s\n⊢ (swap x b) x ∈ s ↔ x ∈ s",
"case inr\nα : Type u_1\ns : Set α\ninst✝ : DecidableEq α\na b : α\nha : a ∈ s\nhb : b ∈ s\nx : α\nhxa : x ≠ a\n⊢ (swap a b) x ∈ s ↔ x ∈ s"
] | obtain rfl | hxa := eq_or_ne x a | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Algebra.Group.Basic | {
"line": 171,
"column": 26
} | {
"line": 171,
"column": 53
} | {
"line": 173,
"column": 0
} | [
{
"pp": "M : Type u_4\ninst✝ : Monoid M\na : M\nn m : ℕ\nha : a ^ n = 1\n⊢ a ^ (m % n + n * (m / n)) = a ^ (m % n)",
"ppTerm": "?m.59",
"assigned": true,
"usedConstants": [
"one_pow",
"MulOne.toOne",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
... | [] | simp [pow_add, pow_mul, ha] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Group.Basic | {
"line": 171,
"column": 26
} | {
"line": 171,
"column": 53
} | {
"line": 173,
"column": 0
} | [
{
"pp": "M : Type u_4\ninst✝ : Monoid M\na : M\nn m : ℕ\nha : a ^ n = 1\n⊢ a ^ (m % n + n * (m / n)) = a ^ (m % n)",
"ppTerm": "?m.59",
"assigned": true,
"usedConstants": [
"one_pow",
"MulOne.toOne",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
... | [] | simp [pow_add, pow_mul, ha] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Basic | {
"line": 171,
"column": 26
} | {
"line": 171,
"column": 53
} | {
"line": 173,
"column": 0
} | [
{
"pp": "M : Type u_4\ninst✝ : Monoid M\na : M\nn m : ℕ\nha : a ^ n = 1\n⊢ a ^ (m % n + n * (m / n)) = a ^ (m % n)",
"ppTerm": "?m.59",
"assigned": true,
"usedConstants": [
"one_pow",
"MulOne.toOne",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
... | [] | simp [pow_add, pow_mul, ha] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Basic | {
"line": 801,
"column": 4
} | {
"line": 801,
"column": 62
} | {
"line": 802,
"column": 4
} | [
{
"pp": "G : Type u_3\ninst✝ : Group G\na : G\nn : ℕ\n⊢ a ^ (Int.negSucc (n + 1) + 1) = (a ^ (n + 1))⁻¹",
"ppTerm": "?m.79",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"congrArg",
"Int.neg_add_cancel_right",
"DivInvMonoid.toZPow",
"Group.... | [
"G : Type u_3\ninst✝ : Group G\na : G\nn : ℕ\n⊢ a ^ (-↑(n + 1)) = (a ^ (n + 1))⁻¹"
] | rw [Int.negSucc_eq, Int.neg_add, Int.neg_add_cancel_right] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Units.Defs | {
"line": 234,
"column": 19
} | {
"line": 234,
"column": 60
} | {
"line": 235,
"column": 8
} | [
{
"pp": "α : Type u\ninst✝ : Monoid α\na✝ b u : αˣ\nn : ℕ\na : αˣ\n⊢ ↑a ^ n * ↑a⁻¹ ^ n = 1",
"ppTerm": "?m.55",
"assigned": true,
"usedConstants": [
"one_pow",
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Uni... | [] | by rw [← a.commute_coe_inv.mul_pow]; simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Units.Defs | {
"line": 595,
"column": 2
} | {
"line": 595,
"column": 21
} | {
"line": 595,
"column": 21
} | [
{
"pp": "α : Type u\ninst✝ : DivisionMonoid α\na b : α\nha : IsUnit a\nhb : IsUnit b\n⊢ IsUnit (a / b)",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"IsU... | [
"α : Type u\ninst✝ : DivisionMonoid α\na b : α\nha : IsUnit a\nhb : IsUnit b\n⊢ IsUnit (a * b⁻¹)"
] | rw [div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Control.Basic | {
"line": 128,
"column": 2
} | {
"line": 128,
"column": 75
} | {
"line": 130,
"column": 0
} | [
{
"pp": "m : Type u → Type u\ninst✝¹ : Monad m\ninst✝ : LawfulMonad m\nα : Type u\na : m α\n⊢ joinM (pure <$> a) = a",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Pure.pure",
"congrArg",
"LawfulMonad.bind_assoc",
"Monad.toApplicative",
"id",
"Applicat... | [] | simp only [joinM, id, ← bind_pure_comp, bind_assoc, pure_bind, bind_pure] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Control.Basic | {
"line": 128,
"column": 2
} | {
"line": 128,
"column": 75
} | {
"line": 130,
"column": 0
} | [
{
"pp": "m : Type u → Type u\ninst✝¹ : Monad m\ninst✝ : LawfulMonad m\nα : Type u\na : m α\n⊢ joinM (pure <$> a) = a",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Pure.pure",
"congrArg",
"LawfulMonad.bind_assoc",
"Monad.toApplicative",
"id",
"Applicat... | [] | simp only [joinM, id, ← bind_pure_comp, bind_assoc, pure_bind, bind_pure] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Control.Basic | {
"line": 128,
"column": 2
} | {
"line": 128,
"column": 75
} | {
"line": 130,
"column": 0
} | [
{
"pp": "m : Type u → Type u\ninst✝¹ : Monad m\ninst✝ : LawfulMonad m\nα : Type u\na : m α\n⊢ joinM (pure <$> a) = a",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Pure.pure",
"congrArg",
"LawfulMonad.bind_assoc",
"Monad.toApplicative",
"id",
"Applicat... | [] | simp only [joinM, id, ← bind_pure_comp, bind_assoc, pure_bind, bind_pure] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GroupWithZero.Basic | {
"line": 65,
"column": 27
} | {
"line": 65,
"column": 47
} | {
"line": 65,
"column": 48
} | [
{
"pp": "M₀ : Type u_1\ninst✝ : MulZeroClass M₀\na b : M₀\nh : a ≠ 0 → b = 0\nthis : Decidable (a = 0)\nha : a = 0\n⊢ a * b = 0",
"ppTerm": "?m.30",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"MulZeroClass.zero_mul",
... | [] | by rw [ha, zero_mul] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Cast.Defs | {
"line": 165,
"column": 2
} | {
"line": 165,
"column": 8
} | {
"line": 167,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝ : AddMonoidWithOne R\n⊢ 1 + 1 = 2",
"ppTerm": "?m.26",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Bool",
"instAddNat",
"Eq.refl"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Nat.Cast.Defs | {
"line": 170,
"column": 2
} | {
"line": 170,
"column": 8
} | {
"line": 172,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝ : AddMonoidWithOne R\n⊢ 1 + 1 + 1 = 3",
"ppTerm": "?m.34",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Bool",
"instAddNat",
"Eq.r... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Nat.Cast.Defs | {
"line": 176,
"column": 2
} | {
"line": 176,
"column": 8
} | {
"line": 178,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝ : AddMonoidWithOne R\n⊢ 1 + 1 + 1 + 1 = 4",
"ppTerm": "?m.42",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Bool",
"instAddNat",
"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.GroupWithZero.Action.Defs | {
"line": 436,
"column": 4
} | {
"line": 437,
"column": 21
} | {
"line": 439,
"column": 0
} | [
{
"pp": "M : Type u_1\nM₀ : Type u_2\nM₀' : Type u_3\nG₀ : Type u_4\nG₀' : Type u_5\nN : Type u_6\nA : Type u_7\nA' : Type u_8\nB : Type u_9\nα : Type u_10\nβ : Type u_11\ninst✝² : Group α\ninst✝¹ : GroupWithZero β\ninst✝ : MulDistribMulAction α β\ng : α\n⊢ ¬g • 0 * (g • 0)⁻¹ = 1",
"ppTerm": "?m.17",
"a... | [] | rw [← smul_one g, ← inv_smul_eq_iff, smul_mul', inv_smul_smul, zero_mul]
exact zero_ne_one | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.GroupWithZero.Action.Defs | {
"line": 436,
"column": 4
} | {
"line": 437,
"column": 21
} | {
"line": 439,
"column": 0
} | [
{
"pp": "M : Type u_1\nM₀ : Type u_2\nM₀' : Type u_3\nG₀ : Type u_4\nG₀' : Type u_5\nN : Type u_6\nA : Type u_7\nA' : Type u_8\nB : Type u_9\nα : Type u_10\nβ : Type u_11\ninst✝² : Group α\ninst✝¹ : GroupWithZero β\ninst✝ : MulDistribMulAction α β\ng : α\n⊢ ¬g • 0 * (g • 0)⁻¹ = 1",
"ppTerm": "?m.17",
"a... | [] | rw [← smul_one g, ← inv_smul_eq_iff, smul_mul', inv_smul_smul, zero_mul]
exact zero_ne_one | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Nat.Even | {
"line": 88,
"column": 31
} | {
"line": 88,
"column": 37
} | {
"line": 90,
"column": 0
} | [
{
"pp": "m n : ℕ\n⊢ ¬Even 25394535",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"instOfNatNat",
"Nat.instDecidablePredEven",
"Bool.true",
"Nat",
"Even",
"Bool",
"instAddNat",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Group.Nat.Even | {
"line": 88,
"column": 31
} | {
"line": 88,
"column": 37
} | {
"line": 90,
"column": 0
} | [
{
"pp": "m n : ℕ\n⊢ ¬Even 25394535",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"instOfNatNat",
"Nat.instDecidablePredEven",
"Bool.true",
"Nat",
"Even",
"Bool",
"instAddNat",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Nat.Even | {
"line": 88,
"column": 31
} | {
"line": 88,
"column": 37
} | {
"line": 90,
"column": 0
} | [
{
"pp": "m n : ℕ\n⊢ ¬Even 25394535",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"instOfNatNat",
"Nat.instDecidablePredEven",
"Bool.true",
"Nat",
"Even",
"Bool",
"instAddNat",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Int.Even | {
"line": 84,
"column": 37
} | {
"line": 84,
"column": 43
} | {
"line": 86,
"column": 0
} | [
{
"pp": "m n : ℤ\n⊢ ¬Even 25394535",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Int.instDecidablePredEven",
"id",
"Int",
"Bool.true",
"instOfNat",
"Even",
"Bool",
"Int.instAdd",
"E... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Group.Int.Even | {
"line": 84,
"column": 37
} | {
"line": 84,
"column": 43
} | {
"line": 86,
"column": 0
} | [
{
"pp": "m n : ℤ\n⊢ ¬Even 25394535",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Int.instDecidablePredEven",
"id",
"Int",
"Bool.true",
"instOfNat",
"Even",
"Bool",
"Int.instAdd",
"E... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Int.Even | {
"line": 84,
"column": 37
} | {
"line": 84,
"column": 43
} | {
"line": 86,
"column": 0
} | [
{
"pp": "m n : ℤ\n⊢ ¬Even 25394535",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Int.instDecidablePredEven",
"id",
"Int",
"Bool.true",
"instOfNat",
"Even",
"Bool",
"Int.instAdd",
"E... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Hom.Instances | {
"line": 87,
"column": 22
} | {
"line": 87,
"column": 40
} | {
"line": 87,
"column": 41
} | [
{
"pp": "M : Type uM\nN : Type uN\nP : Type uP\nQ : Type uQ\ninst✝¹ : MulOneClass M\ninst✝ : CommGroup N\nf : M →* N\nn : ℤ\nx y : M\n⊢ (⇑f ^ n) (x * y) = (⇑f ^ n) x * (⇑f ^ n) y",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"MonoidHom.instMonoidHomClass",
"MonoidHom.instFunL... | [] | by simp [mul_zpow] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.GroupWithZero.Commute | {
"line": 91,
"column": 2
} | {
"line": 91,
"column": 21
} | {
"line": 92,
"column": 2
} | [
{
"pp": "G₀ : Type u_2\ninst✝ : GroupWithZero G₀\na b c : G₀\nhac : Commute a c\nhbc : Commute b c\n⊢ Commute (a / b) c",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
... | [
"G₀ : Type u_2\ninst✝ : GroupWithZero G₀\na b c : G₀\nhac : Commute a c\nhbc : Commute b c\n⊢ Commute (a * b⁻¹) c"
] | rw [div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.GroupWithZero.Units.Basic | {
"line": 167,
"column": 4
} | {
"line": 168,
"column": 42
} | {
"line": 169,
"column": 2
} | [
{
"pp": "case inr.inl\nM₀ : Type u_2\ninst✝ : MonoidWithZero M₀\na b : M₀\nh : IsUnit a ∨ IsUnit b\nha : ¬IsUnit a\nhb : IsUnit b\n⊢ (a * b)⁻¹ʳ = b⁻¹ʳ * a⁻¹ʳ",
"ppTerm": "?inr.inl",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"HMul.hMul",
"eq_false",
"MulZer... | [] | have : ¬ IsUnit (a * b) := by simpa [hb.mul_right_iff]
simp [Ring.inverse_non_unit, ha, this] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.GroupWithZero.Units.Basic | {
"line": 167,
"column": 4
} | {
"line": 168,
"column": 42
} | {
"line": 169,
"column": 2
} | [
{
"pp": "case inr.inl\nM₀ : Type u_2\ninst✝ : MonoidWithZero M₀\na b : M₀\nh : IsUnit a ∨ IsUnit b\nha : ¬IsUnit a\nhb : IsUnit b\n⊢ (a * b)⁻¹ʳ = b⁻¹ʳ * a⁻¹ʳ",
"ppTerm": "?inr.inl",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"HMul.hMul",
"eq_false",
"MulZer... | [] | have : ¬ IsUnit (a * b) := by simpa [hb.mul_right_iff]
simp [Ring.inverse_non_unit, ha, this] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GroupWithZero.Units.Basic | {
"line": 285,
"column": 2
} | {
"line": 285,
"column": 21
} | {
"line": 286,
"column": 2
} | [
{
"pp": "G₀ : Type u_3\ninst✝ : GroupWithZero G₀\na b : G₀\nha : a ≠ 0\nhb : b ≠ 0\n⊢ a / b ≠ 0",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"GroupWithZero.toDi... | [
"G₀ : Type u_3\ninst✝ : GroupWithZero G₀\na b : G₀\nha : a ≠ 0\nhb : b ≠ 0\n⊢ a * b⁻¹ ≠ 0"
] | rw [div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.GroupWithZero.Units.Basic | {
"line": 327,
"column": 2
} | {
"line": 327,
"column": 32
} | {
"line": 327,
"column": 32
} | [
{
"pp": "G₀ : Type u_3\ninst✝ : GroupWithZero G₀\na b c : G₀\nhb : b ≠ 0\nh : b = a⁻¹ * c\n⊢ a * b = c",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"GroupWithZero.toDivisionMonoid",
"HMul.hMul",
"DivInvOneMonoid.t... | [
"G₀ : Type u_3\ninst✝ : GroupWithZero G₀\na b c : G₀\nhb : b ≠ 0\nh : b = a⁻¹ * c\n⊢ a ≠ 0"
] | rwa [← eq_inv_mul_iff_mul_eq₀] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Algebra.Ring.Commute | {
"line": 129,
"column": 47
} | {
"line": 129,
"column": 70
} | {
"line": 129,
"column": 71
} | [
{
"pp": "R : Type u\ninst✝¹ : Ring R\na b : R\ninst✝ : NoZeroDivisors R\nh : Commute a b\n⊢ a + b = 0 ∨ a - b = 0 ↔ a = b ∨ a = -b",
"ppTerm": "?m.48",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"AddGroupWithOne.toAddG... | [
"R : Type u\ninst✝¹ : Ring R\na b : R\ninst✝ : NoZeroDivisors R\nh : Commute a b\n⊢ a = -b ∨ a - b = 0 ↔ a = b ∨ a = -b"
] | add_eq_zero_iff_eq_neg, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Int.Cast.Lemmas | {
"line": 314,
"column": 68
} | {
"line": 314,
"column": 86
} | {
"line": 314,
"column": 87
} | [
{
"pp": "F : Type u_1\nι : Type u_2\nα : Type u_3\nβ : Type u_4\ninst✝¹ : CommGroup α\ninst✝ : AddCommGroup β\na b : α\nn : Multiplicative ℤ\n⊢ ((zpowersHom α).toFun (a * b)) n = ((zpowersHom α).toFun a * (zpowersHom α).toFun b) n",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Mono... | [] | by simp [mul_zpow] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.ZeroLEOne | {
"line": 67,
"column": 60
} | {
"line": 67,
"column": 66
} | {
"line": 67,
"column": 66
} | [
{
"pp": "α : Type u_1\n⊢ 0 ≤ 1",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Rat.instOfNat",
"Rat.instDecidableLe",
"of_decide_eq_true",
"Rat",
"Zero.ofOfNat0",
"id",
"LE.le",
"Rat.instLE",
"Bool.true",
"Bool",
"One.toOfNa... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Order.ZeroLEOne | {
"line": 67,
"column": 60
} | {
"line": 67,
"column": 66
} | {
"line": 67,
"column": 66
} | [
{
"pp": "α : Type u_1\n⊢ 0 ≤ 1",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Rat.instOfNat",
"Rat.instDecidableLe",
"of_decide_eq_true",
"Rat",
"Zero.ofOfNat0",
"id",
"LE.le",
"Rat.instLE",
"Bool.true",
"Bool",
"One.toOfNa... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.ZeroLEOne | {
"line": 67,
"column": 60
} | {
"line": 67,
"column": 66
} | {
"line": 67,
"column": 66
} | [
{
"pp": "α : Type u_1\n⊢ 0 ≤ 1",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Rat.instOfNat",
"Rat.instDecidableLe",
"of_decide_eq_true",
"Rat",
"Zero.ofOfNat0",
"id",
"LE.le",
"Rat.instLE",
"Bool.true",
"Bool",
"One.toOfNa... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Ring.Parity | {
"line": 349,
"column": 31
} | {
"line": 349,
"column": 37
} | {
"line": 351,
"column": 0
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nm n : ℕ\n⊢ ¬Even 25394535",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"instOfNatNat",
"Nat.instDecidablePredEven",
"Bool.true",
"Nat",
"Even"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Ring.Parity | {
"line": 349,
"column": 31
} | {
"line": 349,
"column": 37
} | {
"line": 351,
"column": 0
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nm n : ℕ\n⊢ ¬Even 25394535",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"instOfNatNat",
"Nat.instDecidablePredEven",
"Bool.true",
"Nat",
"Even"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Ring.Parity | {
"line": 349,
"column": 31
} | {
"line": 349,
"column": 37
} | {
"line": 351,
"column": 0
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nm n : ℕ\n⊢ ¬Even 25394535",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"instOfNatNat",
"Nat.instDecidablePredEven",
"Bool.true",
"Nat",
"Even"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Monoid.Unbundled.Basic | {
"line": 321,
"column": 2
} | {
"line": 325,
"column": 50
} | {
"line": 327,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝² : Mul α\ninst✝¹ : PartialOrder α\ninst✝ : MulLeftStrictMono α\na b c : α\nh : b ≤ c ∨ c ≤ b\n⊢ a * c = a * b ↔ c = b",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"HMul.hMul",
"PartialOrder.toPreorder",
"Preorder.toLE... | [] | refine ⟨fun h' => ?_, (· ▸ rfl)⟩
contrapose h'
obtain h | h := h
· exact mul_lt_mul_right (h.lt_of_ne' h') a |>.ne'
· exact mul_lt_mul_right (h.lt_of_ne h') a |>.ne | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Monoid.Unbundled.Basic | {
"line": 321,
"column": 2
} | {
"line": 325,
"column": 50
} | {
"line": 327,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝² : Mul α\ninst✝¹ : PartialOrder α\ninst✝ : MulLeftStrictMono α\na b c : α\nh : b ≤ c ∨ c ≤ b\n⊢ a * c = a * b ↔ c = b",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"HMul.hMul",
"PartialOrder.toPreorder",
"Preorder.toLE... | [] | refine ⟨fun h' => ?_, (· ▸ rfl)⟩
contrapose h'
obtain h | h := h
· exact mul_lt_mul_right (h.lt_of_ne' h') a |>.ne'
· exact mul_lt_mul_right (h.lt_of_ne h') a |>.ne | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Monoid.Unbundled.Basic | {
"line": 342,
"column": 4
} | {
"line": 342,
"column": 74
} | {
"line": 344,
"column": 0
} | [
{
"pp": "case inr.inr.inr.inr\nα : Type u_1\ninst✝³ : Mul α\ninst✝² : LinearOrder α\na b c d : α\ninst✝¹ : MulLeftStrictMono α\ninst✝ : MulRightStrictMono α\nh : a * b = c * d\nhca : c < a\nhdb : d < b\n⊢ a = c ∧ b = d ∨ a < c ∨ b < d",
"ppTerm": "?inr.inr.inr.inr",
"assigned": true,
"usedConstants"... | [] | · exact False.elim <| ne_of_lt (mul_lt_mul_of_lt_of_lt hca hdb) h.symm | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Order.Monoid.Unbundled.ExistsOfLE | {
"line": 52,
"column": 30
} | {
"line": 53,
"column": 81
} | {
"line": 55,
"column": 0
} | [
{
"pp": "α : Type u\ninst✝³ : MulOneClass α\ninst✝² : Preorder α\ninst✝¹ : ExistsMulOfLE α\na b : α\ninst✝ : MulLeftReflectLE α\nh : a ≤ b\n⊢ ∃ c, 1 ≤ c ∧ a * c = b",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"one_le_of_le_mul_right",
"MulOne.toOne",
"HMul.hMul",
... | [] | by
obtain ⟨c, rfl⟩ := exists_mul_of_le h; exact ⟨c, one_le_of_le_mul_right h, rfl⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Ring.Defs | {
"line": 131,
"column": 62
} | {
"line": 131,
"column": 78
} | {
"line": 131,
"column": 78
} | [
{
"pp": "R : Type u_1\ninst✝⁴ : AddMonoidWithOne R\ninst✝³ : PartialOrder R\ninst✝² : ZeroLEOneClass R\ninst✝¹ : NeZero 1\ninst✝ : AddLeftStrictMono R\nn : ℕ\n⊢ ↑n < ↑n + 1",
"ppTerm": "?m.30",
"assigned": true,
"usedConstants": [
"lt_add_one",
"AddMonoid.toAddZeroClass",
"AddMonoi... | [] | apply lt_add_one | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 565,
"column": 4
} | {
"line": 565,
"column": 92
} | {
"line": 567,
"column": 0
} | [
{
"pp": "M₀ : Type u_2\ninst✝³ : MonoidWithZero M₀\ninst✝² : PartialOrder M₀\na : M₀\ninst✝¹ : PosMulStrictMono M₀\ninst✝ : ZeroLEOneClass M₀\nh : 1 < a\nn : ℕ\n⊢ a ^ n < a ^ (n + 1)",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"pow_pos",
... | [] | simpa only [one_mul, pow_succ] using lt_mul_right (pow_pos (zero_le_one.trans_lt h) _) h | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 565,
"column": 4
} | {
"line": 565,
"column": 92
} | {
"line": 567,
"column": 0
} | [
{
"pp": "M₀ : Type u_2\ninst✝³ : MonoidWithZero M₀\ninst✝² : PartialOrder M₀\na : M₀\ninst✝¹ : PosMulStrictMono M₀\ninst✝ : ZeroLEOneClass M₀\nh : 1 < a\nn : ℕ\n⊢ a ^ n < a ^ (n + 1)",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"pow_pos",
... | [] | simpa only [one_mul, pow_succ] using lt_mul_right (pow_pos (zero_le_one.trans_lt h) _) h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 565,
"column": 4
} | {
"line": 565,
"column": 92
} | {
"line": 567,
"column": 0
} | [
{
"pp": "M₀ : Type u_2\ninst✝³ : MonoidWithZero M₀\ninst✝² : PartialOrder M₀\na : M₀\ninst✝¹ : PosMulStrictMono M₀\ninst✝ : ZeroLEOneClass M₀\nh : 1 < a\nn : ℕ\n⊢ a ^ n < a ^ (n + 1)",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"pow_pos",
... | [] | simpa only [one_mul, pow_succ] using lt_mul_right (pow_pos (zero_le_one.trans_lt h) _) h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 881,
"column": 2
} | {
"line": 881,
"column": 21
} | {
"line": 881,
"column": 21
} | [
{
"pp": "G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : PartialOrder G₀\ninst✝ : PosMulReflectLT G₀\na b : G₀\nha : 0 < a\nhb : 0 < b\n⊢ 0 < a / b",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"DivInvMonoid.toInv",
"... | [
"G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : PartialOrder G₀\ninst✝ : PosMulReflectLT G₀\na b : G₀\nha : 0 < a\nhb : 0 < b\n⊢ 0 < a * b⁻¹"
] | rw [div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 884,
"column": 2
} | {
"line": 884,
"column": 21
} | {
"line": 884,
"column": 21
} | [
{
"pp": "G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : PartialOrder G₀\ninst✝ : PosMulReflectLT G₀\na b : G₀\nha : 0 ≤ a\nhb : 0 ≤ b\n⊢ 0 ≤ a / b",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"DivInvMonoid.toInv",
"... | [
"G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : PartialOrder G₀\ninst✝ : PosMulReflectLT G₀\na b : G₀\nha : 0 ≤ a\nhb : 0 ≤ b\n⊢ 0 ≤ a * b⁻¹"
] | rw [div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 974,
"column": 2
} | {
"line": 974,
"column": 43
} | {
"line": 975,
"column": 2
} | [
{
"pp": "G₀ : Type u_3\ninst✝³ : GroupWithZero G₀\ninst✝² : PartialOrder G₀\ninst✝¹ : PosMulReflectLT G₀\na : G₀\ninst✝ : ZeroLEOneClass G₀\nha : 1 ≤ a\n⊢ Monotone fun n ↦ a ^ n",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"GroupWithZero.toDivInvMonoid",
"PartialOrder.toPreo... | [
"G₀ : Type u_3\ninst✝³ : GroupWithZero G₀\ninst✝² : PartialOrder G₀\ninst✝¹ : PosMulReflectLT G₀\na : G₀\ninst✝ : ZeroLEOneClass G₀\nha : 1 ≤ a\nn : ℤ\n⊢ a ^ n ≤ a ^ (n + 1)"
] | refine monotone_int_of_le_succ fun n ↦ ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 1044,
"column": 73
} | {
"line": 1045,
"column": 37
} | {
"line": 1047,
"column": 0
} | [
{
"pp": "G₀ : Type u_3\ninst✝³ : GroupWithZero G₀\ninst✝² : PartialOrder G₀\ninst✝¹ : PosMulReflectLT G₀\na : G₀\ninst✝ : ZeroLEOneClass G₀\nn : ℤ\nha : 1 < a\n⊢ 1 < a ^ n ↔ 0 < n",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Preorder.toLT",
"GroupWithZ... | [] | by
simp [← zpow_lt_zpow_iff_right₀ ha] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 1056,
"column": 73
} | {
"line": 1057,
"column": 37
} | {
"line": 1059,
"column": 0
} | [
{
"pp": "G₀ : Type u_3\ninst✝³ : GroupWithZero G₀\ninst✝² : PartialOrder G₀\ninst✝¹ : PosMulReflectLT G₀\na : G₀\ninst✝ : ZeroLEOneClass G₀\nn : ℤ\nha : 1 < a\n⊢ a ^ n < 1 ↔ n < 0",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Preorder.toLT",
"GroupWithZ... | [] | by
simp [← zpow_lt_zpow_iff_right₀ ha] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 1115,
"column": 2
} | {
"line": 1115,
"column": 21
} | {
"line": 1115,
"column": 21
} | [
{
"pp": "G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : PartialOrder G₀\ninst✝ : MulPosReflectLT G₀\na b : G₀\nha : a ≤ 0\nhb : 0 ≤ b\n⊢ a / b ≤ 0",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"DivInvMonoid.toInv",
"... | [
"G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : PartialOrder G₀\ninst✝ : MulPosReflectLT G₀\na b : G₀\nha : a ≤ 0\nhb : 0 ≤ b\n⊢ a * b⁻¹ ≤ 0"
] | rw [div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 1323,
"column": 2
} | {
"line": 1323,
"column": 21
} | {
"line": 1323,
"column": 21
} | [
{
"pp": "G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : LinearOrder G₀\na b : G₀\ninst✝ : PosMulMono G₀\nha : 0 ≤ a\nhb : b ≤ 0\n⊢ a / b ≤ 0",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"DivInvMonoid.toInv",
"instHD... | [
"G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : LinearOrder G₀\na b : G₀\ninst✝ : PosMulMono G₀\nha : 0 ≤ a\nhb : b ≤ 0\n⊢ a * b⁻¹ ≤ 0"
] | rw [div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Archimedean.Defs | {
"line": 100,
"column": 10
} | {
"line": 100,
"column": 45
} | {
"line": 100,
"column": 45
} | [
{
"pp": "R : Type u_1\ninst✝³ : Ring R\ninst✝² : PartialOrder R\ninst✝¹ : IsStrictOrderedRing R\ninst✝ : Archimedean R\nx : R\nn : ℤ\nh : -x < ↑n\n⊢ ↑(-n) < x",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"AddGroup.toSubt... | [] | rw [Int.cast_neg]; exact neg_lt.1 h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Archimedean.Defs | {
"line": 100,
"column": 10
} | {
"line": 100,
"column": 45
} | {
"line": 100,
"column": 45
} | [
{
"pp": "R : Type u_1\ninst✝³ : Ring R\ninst✝² : PartialOrder R\ninst✝¹ : IsStrictOrderedRing R\ninst✝ : Archimedean R\nx : R\nn : ℤ\nh : -x < ↑n\n⊢ ↑(-n) < x",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"AddGroup.toSubt... | [] | rw [Int.cast_neg]; exact neg_lt.1 h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Group.Abs | {
"line": 241,
"column": 2
} | {
"line": 241,
"column": 6
} | {
"line": 242,
"column": 2
} | [
{
"pp": "G : Type u_1\ninst✝² : CommGroup G\ninst✝¹ : LinearOrder G\ninst✝ : IsOrderedMonoid G\na : G\n⊢ max a 1 * max a⁻¹ 1 = |a|ₘ",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"Lattice.toSemilatticeSup",
"InvOneClass.toOne",
"HMul.hMul",
"DivisionCommMonoid.toDi... | [
"G : Type u_1\ninst✝² : CommGroup G\ninst✝¹ : LinearOrder G\ninst✝ : IsOrderedMonoid G\na : G\n⊢ |a|ₘ = max a 1 * max a⁻¹ 1"
] | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Algebra.Ring.Int.Parity | {
"line": 136,
"column": 27
} | {
"line": 136,
"column": 33
} | {
"line": 136,
"column": 33
} | [
{
"pp": "p : ℕ\n⊢ 0 < 2",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",
"Bool",
"Nat.decLt",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
"Decidable.dec... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Ring.Int.Parity | {
"line": 136,
"column": 27
} | {
"line": 136,
"column": 33
} | {
"line": 136,
"column": 33
} | [
{
"pp": "p : ℕ\n⊢ 0 < 2",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",
"Bool",
"Nat.decLt",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
"Decidable.dec... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Ring.Int.Parity | {
"line": 136,
"column": 27
} | {
"line": 136,
"column": 33
} | {
"line": 136,
"column": 33
} | [
{
"pp": "p : ℕ\n⊢ 0 < 2",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",
"Bool",
"Nat.decLt",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
"Decidable.dec... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Ring.Int.Parity | {
"line": 150,
"column": 4
} | {
"line": 150,
"column": 18
} | {
"line": 151,
"column": 2
} | [
{
"pp": "case ofNat\nα : Type u_1\ninst✝¹ : DivisionMonoid α\ninst✝ : HasDistribNeg α\na : α\nk : ℕ\n⊢ (-a) ^ (2 * k + 1) = -a ^ (2 * k + 1)",
"ppTerm": "?ofNat",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"even_two._simp_1",
"AddMonoid.toAddSemigroup",
"Monoid.toMulOn... | [] | simp [pow_add] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Ring.Int.Parity | {
"line": 154,
"column": 4
} | {
"line": 154,
"column": 18
} | {
"line": 156,
"column": 0
} | [
{
"pp": "case negSucc\nα : Type u_1\ninst✝¹ : DivisionMonoid α\ninst✝ : HasDistribNeg α\na : α\nk : ℕ\n⊢ ((-a) ^ (1 + k * 2))⁻¹ = -(a ^ (1 + k * 2))⁻¹",
"ppTerm": "?negSucc",
"assigned": true,
"usedConstants": [
"Distrib.leftDistribClass",
"DivInvMonoid.toInv",
"HMul.hMul",
"... | [] | simp [pow_add] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Order.Group.Unbundled.Abs | {
"line": 243,
"column": 4
} | {
"line": 243,
"column": 60
} | {
"line": 244,
"column": 2
} | [
{
"pp": "case inl\nα : Type u_1\ninst✝² : Group α\ninst✝¹ : LinearOrder α\ninst✝ : MulLeftMono α\na : α\nh : 1 ≤ a\n⊢ |a|ₘ⁻¹ ≤ a",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"inv_le_one'",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneCl... | [] | simpa [mabs_of_one_le h] using (inv_le_one'.2 h).trans h | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Order.Group.Unbundled.Abs | {
"line": 243,
"column": 4
} | {
"line": 243,
"column": 60
} | {
"line": 244,
"column": 2
} | [
{
"pp": "case inl\nα : Type u_1\ninst✝² : Group α\ninst✝¹ : LinearOrder α\ninst✝ : MulLeftMono α\na : α\nh : 1 ≤ a\n⊢ |a|ₘ⁻¹ ≤ a",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"inv_le_one'",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneCl... | [] | simpa [mabs_of_one_le h] using (inv_le_one'.2 h).trans h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Group.Unbundled.Abs | {
"line": 243,
"column": 4
} | {
"line": 243,
"column": 60
} | {
"line": 244,
"column": 2
} | [
{
"pp": "case inl\nα : Type u_1\ninst✝² : Group α\ninst✝¹ : LinearOrder α\ninst✝ : MulLeftMono α\na : α\nh : 1 ≤ a\n⊢ |a|ₘ⁻¹ ≤ a",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"inv_le_one'",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneCl... | [] | simpa [mabs_of_one_le h] using (inv_le_one'.2 h).trans h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Ring.Int | {
"line": 54,
"column": 24
} | {
"line": 54,
"column": 30
} | {
"line": 54,
"column": 30
} | [
{
"pp": "m : ℤ\neven : Even m\n⊢ 0 < 2",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"Int",
"Int.instLTInt",
"Bool.true",
"instOfNat",
"LT.lt",
"Bool",
"Eq.refl",
"Int.decLt",
"OfNat.ofNat",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Order.Ring.Int | {
"line": 54,
"column": 24
} | {
"line": 54,
"column": 30
} | {
"line": 54,
"column": 30
} | [
{
"pp": "m : ℤ\neven : Even m\n⊢ 0 < 2",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"Int",
"Int.instLTInt",
"Bool.true",
"instOfNat",
"LT.lt",
"Bool",
"Eq.refl",
"Int.decLt",
"OfNat.ofNat",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Ring.Int | {
"line": 54,
"column": 24
} | {
"line": 54,
"column": 30
} | {
"line": 54,
"column": 30
} | [
{
"pp": "m : ℤ\neven : Even m\n⊢ 0 < 2",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"Int",
"Int.instLTInt",
"Bool.true",
"instOfNat",
"LT.lt",
"Bool",
"Eq.refl",
"Int.decLt",
"OfNat.ofNat",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Cast.Order.Basic | {
"line": 153,
"column": 57
} | {
"line": 153,
"column": 63
} | {
"line": 153,
"column": 63
} | [
{
"pp": "α : Type u_1\ninst✝¹ : AddMonoidWithOne α\ninst✝ : CharZero α\n⊢ 1 ≠ 0",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Nat.Cast.Order.Basic | {
"line": 153,
"column": 57
} | {
"line": 153,
"column": 63
} | {
"line": 153,
"column": 63
} | [
{
"pp": "α : Type u_1\ninst✝¹ : AddMonoidWithOne α\ninst✝ : CharZero α\n⊢ 1 ≠ 0",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Cast.Order.Basic | {
"line": 153,
"column": 57
} | {
"line": 153,
"column": 63
} | {
"line": 153,
"column": 63
} | [
{
"pp": "α : Type u_1\ninst✝¹ : AddMonoidWithOne α\ninst✝ : CharZero α\n⊢ 1 ≠ 0",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Ring.Int | {
"line": 90,
"column": 6
} | {
"line": 90,
"column": 18
} | {
"line": 90,
"column": 19
} | [
{
"pp": "case succ.succ\nn p q : ℕ\ndvd : ∃ x y, ↑n = ↑(p + 1) * x + ↑(q + 1) * y\nle : (p + 1).pred * (q + 1).pred ≤ n\na_n b_n : ℤ\neq : ↑n = ↑(p + 1) * a_n + ↑(q + 1) * b_n\na : ℤ := a_n % ↑q.succ\nb : ℤ := b_n + a_n / ↑q.succ * ↑p.succ\nthis : a * ↑p.succ + b * ↑q.succ = ↑n\nhb : b ≤ -1\nha : a_n % ↑q.succ ... | [
"case succ.succ\nn p q : ℕ\ndvd : ∃ x y, ↑n = ↑(p + 1) * x + ↑(q + 1) * y\nle : p * (q + 1).pred ≤ n\na_n b_n : ℤ\neq : ↑n = ↑(p + 1) * a_n + ↑(q + 1) * b_n\na : ℤ := a_n % ↑q.succ\nb : ℤ := b_n + a_n / ↑q.succ * ↑p.succ\nthis : a * ↑p.succ + b * ↑q.succ = ↑n\nhb : b ≤ -1\nha : a_n % ↑q.succ < ↑(↑q.succ).natAbs\n⊢ ... | p.pred_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Monoid.Canonical.Defs | {
"line": 178,
"column": 4
} | {
"line": 178,
"column": 37
} | {
"line": 180,
"column": 0
} | [
{
"pp": "α : Type u\ninst✝² : Semigroup α\ninst✝¹ : LE α\ninst✝ : CanonicallyOrderedMul α\na b c : α\nhbc : b ≤ b * c\n⊢ ∃ c_1, (fun x1 x2 ↦ x1 * x2) a (b * c) = (fun x1 x2 ↦ x1 * x2) a b * c_1",
"ppTerm": "?m.71",
"assigned": true,
"usedConstants": [
"Semigroup.toMul",
"HMul.hMul",
... | [] | exact ⟨c, (mul_assoc _ _ _).symm⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.Monoid.WithTop | {
"line": 54,
"column": 4
} | {
"line": 55,
"column": 21
} | {
"line": 57,
"column": 0
} | [
{
"pp": "case coe.coe\nα : Type u\ninst✝² : Add α\ninst✝¹ : LE α\ninst✝ : CanonicallyOrderedAdd α\na✝¹ : α\nhx : ↑a✝¹ ≠ ⊥\na✝ : α\n⊢ ↑a✝ ≤ ↑a✝ + ↑a✝¹",
"ppTerm": "?coe.coe",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"WithBot.some",
"WithBot",
"congrArg",
"id",
... | [] | rw [← WithBot.coe_add, WithBot.coe_le_coe]
exact le_self_add | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Monoid.WithTop | {
"line": 54,
"column": 4
} | {
"line": 55,
"column": 21
} | {
"line": 57,
"column": 0
} | [
{
"pp": "case coe.coe\nα : Type u\ninst✝² : Add α\ninst✝¹ : LE α\ninst✝ : CanonicallyOrderedAdd α\na✝¹ : α\nhx : ↑a✝¹ ≠ ⊥\na✝ : α\n⊢ ↑a✝ ≤ ↑a✝ + ↑a✝¹",
"ppTerm": "?coe.coe",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"WithBot.some",
"WithBot",
"congrArg",
"id",
... | [] | rw [← WithBot.coe_add, WithBot.coe_le_coe]
exact le_self_add | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GroupWithZero.WithZero | {
"line": 412,
"column": 2
} | {
"line": 412,
"column": 79
} | {
"line": 414,
"column": 0
} | [
{
"pp": "M : Type u_4\ninst✝ : AddMonoid M\nx y : WithZero (Multiplicative M)\nhx : x ≠ 0\nhy : y ≠ 0\n⊢ (x * y).log = x.log + y.log",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"MulZeroClass.toMul",
"WithZero.log",
... | [] | lift x to Multiplicative M using hx; lift y to Multiplicative M using hy; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.GroupWithZero.WithZero | {
"line": 412,
"column": 2
} | {
"line": 412,
"column": 79
} | {
"line": 414,
"column": 0
} | [
{
"pp": "M : Type u_4\ninst✝ : AddMonoid M\nx y : WithZero (Multiplicative M)\nhx : x ≠ 0\nhy : y ≠ 0\n⊢ (x * y).log = x.log + y.log",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"MulZeroClass.toMul",
"WithZero.log",
... | [] | lift x to Multiplicative M using hx; lift y to Multiplicative M using hy; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GroupWithZero.WithZero | {
"line": 411,
"column": 85
} | {
"line": 412,
"column": 79
} | {
"line": 414,
"column": 0
} | [
{
"pp": "M : Type u_4\ninst✝ : AddMonoid M\nx y : WithZero (Multiplicative M)\nhx : x ≠ 0\nhy : y ≠ 0\n⊢ (x * y).log = x.log + y.log",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"MulZeroClass.toMul",
"WithZero.log",
... | [] | by
lift x to Multiplicative M using hx; lift y to Multiplicative M using hy; rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.GroupWithZero.WithZero | {
"line": 439,
"column": 2
} | {
"line": 439,
"column": 38
} | {
"line": 440,
"column": 2
} | [
{
"pp": "G : Type u_5\ninst✝ : AddGroup G\nx : (WithZero (Multiplicative G))ˣ\n⊢ logEquiv x = (↑x).log",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"WithZero.logEquiv",
"Units.val",
"MulOne.toOne",
"Multiplicative.monoid",
"Equiv.instEquivLike",
"HMul.... | [
"case none.none\nG : Type u_5\ninst✝ : AddGroup G\nhab hba : none * none = 1\n⊢ logEquiv { val := none, inv := none, val_inv := hab, inv_val := hba } =\n (↑{ val := none, inv := none, val_inv := hab, inv_val := hba }).log",
"case none.some\nG : Type u_5\ninst✝ : AddGroup G\nb : Multiplicative G\nhab : none * s... | obtain ⟨_ | a, _ | b, hab, hba⟩ := x | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Algebra.Order.Sub.Unbundled.Basic | {
"line": 47,
"column": 55
} | {
"line": 47,
"column": 80
} | {
"line": 47,
"column": 80
} | [
{
"pp": "α : Type u_1\ninst✝⁵ : AddCommSemigroup α\ninst✝⁴ : PartialOrder α\ninst✝³ : ExistsAddOfLE α\ninst✝² : AddLeftMono α\ninst✝¹ : Sub α\ninst✝ : OrderedSub α\na b c : α\nh1 : c ≤ a\nh2 : c ≤ b\n⊢ a - c ≤ b - c ∧ b ≤ a ↔ a ≤ b ∧ b ≤ a",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
... | [] | tsub_le_tsub_iff_right h2 | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Order.Floor.Defs | {
"line": 327,
"column": 46
} | {
"line": 327,
"column": 76
} | {
"line": 327,
"column": 76
} | [
{
"pp": "α : Type u_2\ninst✝² : Ring α\ninst✝¹ : LinearOrder α\ninst✝ : FloorRing α\nz : ℤ\na : α\n⊢ z ≤ ⌈a⌉ ↔ ↑z - 1 < a",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Int.lt_ceil",
"Int.cast",
"Eq.mpr",
"Preorder.toLT",
"AddGroupWithOne.toAddGroup",
... | [
"α : Type u_2\ninst✝² : Ring α\ninst✝¹ : LinearOrder α\ninst✝ : FloorRing α\nz : ℤ\na : α\n⊢ ↑(z - 1) < a ↔ ↑z - 1 < a"
] | rw [← sub_one_lt_iff, lt_ceil] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Floor.Defs | {
"line": 349,
"column": 23
} | {
"line": 349,
"column": 99
} | {
"line": 350,
"column": 2
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝² : Ring α\ninst✝¹ : LinearOrder α\ninst✝ : FloorRing α\na : α\nn : ℕ\nha : 0 ≤ a\n⊢ n ≤ ⌊a⌋.toNat ↔ ↑n ≤ a",
"ppTerm": "?m.52",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Int.cast",
"Eq.mpr",
"NonAssocSemiring.toA... | [] | by rw [Int.le_toNat (Int.floor_nonneg.2 ha), Int.le_floor, Int.cast_natCast] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Floor.Semiring | {
"line": 327,
"column": 2
} | {
"line": 328,
"column": 58
} | {
"line": 330,
"column": 0
} | [
{
"pp": "case inr.inr\nR : Type u_1\ninst✝⁶ : Semiring R\ninst✝⁵ : LinearOrder R\ninst✝⁴ : FloorSemiring R\ninst✝³ : IsStrictOrderedRing R\ninst✝² : Sub R\ninst✝¹ : OrderedSub R\ninst✝ : ExistsAddOfLE R\na : R\nn : ℕ\nha : 0 ≤ a\nh : ↑n ≤ a\n⊢ ⌊a - ↑n⌋₊ = ⌊a⌋₊ - n",
"ppTerm": "?inr.inr",
"assigned": tru... | [] | · rw [eq_tsub_iff_add_eq_of_le (le_floor h), ← floor_add_natCast _, tsub_add_cancel_of_le h]
exact le_tsub_of_add_le_left ((add_zero _).trans_le h) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.Directed | {
"line": 297,
"column": 2
} | {
"line": 297,
"column": 50
} | {
"line": 299,
"column": 0
} | [
{
"pp": "case inl\nβ : Type u_2\ninst✝² : PartialOrder β\ninst✝¹ : Nontrivial β\ninst✝ : IsCodirectedOrder β\na b : β\nhne : a ≠ b\nha : IsBot a\n⊢ ∃ a b, a < b",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"PartialOrder.toPreorder",
"Exists",
"LE.... | [] | exacts [⟨a, b, (ha b).lt_of_ne hne⟩, ⟨_, _, hc⟩] | Batteries.Tactic._aux_Batteries_Tactic_Init___elabRules_Batteries_Tactic_exacts_1 | Batteries.Tactic.exacts |
Mathlib.Algebra.Group.Int.Units | {
"line": 40,
"column": 90
} | {
"line": 40,
"column": 96
} | {
"line": 42,
"column": 0
} | [
{
"pp": "case inl.inl\nhu hv : IsUnit 1\n⊢ 1 ≠ 1 ↔ 1 = -1",
"ppTerm": "?inl.inl",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Int.instDecidableEq",
"id",
"Int.instNegInt",
"Ne",
"Int",
"Bool.true",
"Iff",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Group.Int.Units | {
"line": 40,
"column": 90
} | {
"line": 40,
"column": 96
} | {
"line": 42,
"column": 0
} | [
{
"pp": "case inl.inr\nhu : IsUnit 1\nhv : IsUnit (-1)\n⊢ 1 ≠ -1 ↔ 1 = - -1",
"ppTerm": "?inl.inr",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Int.instDecidableEq",
"id",
"Int.instNegInt",
"Ne",
"Int",
"Bool.true",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Group.Int.Units | {
"line": 40,
"column": 90
} | {
"line": 40,
"column": 96
} | {
"line": 42,
"column": 0
} | [
{
"pp": "case inr.inl\nhu : IsUnit (-1)\nhv : IsUnit 1\n⊢ -1 ≠ 1 ↔ -1 = -1",
"ppTerm": "?inr.inl",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Int.instDecidableEq",
"id",
"Int.instNegInt",
"Ne",
"Int",
"Bool.true",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Group.Int.Units | {
"line": 40,
"column": 90
} | {
"line": 40,
"column": 96
} | {
"line": 42,
"column": 0
} | [
{
"pp": "case inr.inr\nhu hv : IsUnit (-1)\n⊢ -1 ≠ -1 ↔ -1 = - -1",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Int.instDecidableEq",
"id",
"Int.instNegInt",
"Ne",
"Int",
"Bool.true",
"Iff"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Group.Int.Units | {
"line": 49,
"column": 23
} | {
"line": 49,
"column": 29
} | {
"line": 49,
"column": 29
} | [
{
"pp": "⊢ -1 * -1 = 1",
"ppTerm": "?m.59",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"MulOne.toMul",
"Int.instNegInt",
"Int",
"Int.instMonoid... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Group.Int.Units | {
"line": 49,
"column": 23
} | {
"line": 49,
"column": 29
} | {
"line": 49,
"column": 29
} | [
{
"pp": "⊢ -1 * -1 = 1",
"ppTerm": "?m.59",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"MulOne.toMul",
"Int.instNegInt",
"Int",
"Int.instMonoid... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Int.Units | {
"line": 49,
"column": 23
} | {
"line": 49,
"column": 29
} | {
"line": 49,
"column": 29
} | [
{
"pp": "⊢ -1 * -1 = 1",
"ppTerm": "?m.59",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"MulOne.toMul",
"Int.instNegInt",
"Int",
"Int.instMonoid... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Int.Units | {
"line": 49,
"column": 34
} | {
"line": 49,
"column": 40
} | {
"line": 49,
"column": 40
} | [
{
"pp": "⊢ -1 * -1 = 1",
"ppTerm": "?m.60",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"MulOne.toMul",
"Int.instNegInt",
"Int",
"Int.instMonoid... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Group.Int.Units | {
"line": 49,
"column": 34
} | {
"line": 49,
"column": 40
} | {
"line": 49,
"column": 40
} | [
{
"pp": "⊢ -1 * -1 = 1",
"ppTerm": "?m.60",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"MulOne.toMul",
"Int.instNegInt",
"Int",
"Int.instMonoid... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Int.Units | {
"line": 49,
"column": 34
} | {
"line": 49,
"column": 40
} | {
"line": 49,
"column": 40
} | [
{
"pp": "⊢ -1 * -1 = 1",
"ppTerm": "?m.60",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"of_decide_eq_true",
"Monoid.toMulOneClass",
"Int.instDecidableEq",
"id",
"MulOne.toMul",
"Int.instNegInt",
"Int",
"Int.instMonoid... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Ring.Abs | {
"line": 239,
"column": 76
} | {
"line": 240,
"column": 31
} | {
"line": 242,
"column": 0
} | [
{
"pp": "R : Type u_2\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\na : R\nn : ℕ\n⊢ a ^ n = 1 ↔ n = 0 ∨ a = 1 ∨ a = -1 ∧ Even n",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"one_pow",
"NegZeroClass.toNeg",
"MulOne.toOne",
"Monoid.toMulO... | [] | by
simp [← pow_eq_pow_iff_cases] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Ring.Abs | {
"line": 280,
"column": 38
} | {
"line": 280,
"column": 44
} | {
"line": 280,
"column": 44
} | [
{
"pp": "n : ℕ\nhn : Odd n\nhm : 2 ∣ n\n⊢ ¬Odd 2",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Odd",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Nat.instSemiring",
"Eq.refl",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Algebra.Order.Ring.Abs | {
"line": 280,
"column": 38
} | {
"line": 280,
"column": 44
} | {
"line": 280,
"column": 44
} | [
{
"pp": "n : ℕ\nhn : Odd n\nhm : 2 ∣ n\n⊢ ¬Odd 2",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Odd",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Nat.instSemiring",
"Eq.refl",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Ring.Abs | {
"line": 280,
"column": 38
} | {
"line": 280,
"column": 44
} | {
"line": 280,
"column": 44
} | [
{
"pp": "n : ℕ\nhn : Odd n\nhm : 2 ∣ n\n⊢ ¬Odd 2",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Odd",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Nat.instSemiring",
"Eq.refl",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.WellFounded | {
"line": 172,
"column": 2
} | {
"line": 175,
"column": 31
} | {
"line": 177,
"column": 0
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\n⊢ IsWellOrder α r ↔ ∀ (s : Set α), s.Nonempty → ∃ m, m ∈ s ∧ ∀ (x : α), x ∈ s → ¬r x m ∧ (m = x ∨ r m x)",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"IsWellFounded.mk",
"_private.Mathlib.Order.WellFounded.0.WellFounded.isWellOrder_if... | [] | refine ⟨fun h s hs ↦ ?_, fun h ↦ { wf := ?_, trichotomous a b := ?_ }⟩
· grind [h.wf.has_min, trichotomous_of r]
· grind [wellFounded_iff_has_min]
· grind [h {a, b} <| by simp] | 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.