module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.Data.List.Cycle | {
"line": 349,
"column": 4
} | {
"line": 350,
"column": 55
} | {
"line": 352,
"column": 0
} | [
{
"pp": "case h\nα : Type u_1\ninst✝ : DecidableEq α\nl : List α\nh : l.Nodup\n⊢ ∀ (i : ℕ) (h₁ : i < (pmap l.prev l ⋯).length) (h₂ : i < (l.rotate (l.length - 1)).length),\n (pmap l.prev l ⋯)[i] = (l.rotate (l.length - 1))[i]",
"ppTerm": "?h",
"assigned": true,
"usedConstants": [
"Eq.mpr",
... | [] | intro n hn hn'
rw [getElem_rotate, getElem_pmap, prev_getElem _ h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Cycle | {
"line": 379,
"column": 47
} | {
"line": 379,
"column": 58
} | {
"line": 379,
"column": 59
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nl : List α\nh : l.Nodup\nk : ℕ\nhk : k < l.length\nhx : l[k] ∈ l\nlpos : 0 < l.length\nkey : l.length - 1 - k < l.length\n⊢ k < (pmap l.next l ⋯).length",
"ppTerm": "?m.84",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Me... | [
"α : Type u_1\ninst✝ : DecidableEq α\nl : List α\nh : l.Nodup\nk : ℕ\nhk : k < l.length\nhx : l[k] ∈ l\nlpos : 0 < l.length\nkey : l.length - 1 - k < l.length\n⊢ k < l.length"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.List.Cycle | {
"line": 603,
"column": 25
} | {
"line": 603,
"column": 93
} | {
"line": 603,
"column": 94
} | [
{
"pp": "α : Type u_1\nhd : α\ntl : List α\nh : Subsingleton (Quot.mk (⇑(IsRotated.setoid α)) (hd :: tl))\n⊢ tl = []",
"ppTerm": "?m.35",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"α : Type u_1\nhd : α\ntl : List α\nh : Subsingleton (Quot.mk (⇑(IsRotated.setoid α)) (hd :: tl))\n⊢ tl = []"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.List.Cycle | {
"line": 657,
"column": 4
} | {
"line": 657,
"column": 15
} | {
"line": 657,
"column": 16
} | [
{
"pp": "α : Type u_1\ns : Cycle α\nl₁ l₂ : List α\nh : (IsRotated.setoid α) l₁ l₂\n⊢ ↑l₁.cyclicPermutations = ↑l₂.cyclicPermutations",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Multiset",
"id",
"List.Perm",
"List.cyclicPermutations",
"Mul... | [
"α : Type u_1\ns : Cycle α\nl₁ l₂ : List α\nh : (IsRotated.setoid α) l₁ l₂\n⊢ l₁.cyclicPermutations ~ l₂.cyclicPermutations"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.List.Cycle | {
"line": 695,
"column": 72
} | {
"line": 695,
"column": 83
} | {
"line": 695,
"column": 84
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nl : { l // l.Nodup }\n⊢ (↑↑l).Nodup",
"ppTerm": "?m.32",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"id",
"List.Nodup",
"Cycle.ofList",
"List",
"Cycle.nodup_coe_iff._simp_1",
"Subtype.val"... | [
"α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nl : { l // l.Nodup }\n⊢ (↑l).Nodup"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.List.Cycle | {
"line": 733,
"column": 58
} | {
"line": 733,
"column": 85
} | {
"line": 733,
"column": 86
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Cycle α\nl₁ l₂ : List α\nh : (IsRotated.setoid α) l₁ l₂\nh₁ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₁)\nh₂ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₂)\n_he : h₁ ≍ h₂\nx y : α\nhxy : x ≍ y\n⊢ y ∈ Quot.mk (⇑(IsRotated.setoid α)) l₁ ↔ y ∈ Quot.mk (⇑(IsRotated.se... | [
"α : Type u_1\ninst✝ : DecidableEq α\ns : Cycle α\nl₁ l₂ : List α\nh : (IsRotated.setoid α) l₁ l₂\nh₁ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₁)\nh₂ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₂)\n_he : h₁ ≍ h₂\nx y : α\nhxy : x ≍ y\n⊢ y ∈ l₁ ↔ y ∈ l₂"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.List.Cycle | {
"line": 735,
"column": 41
} | {
"line": 735,
"column": 52
} | {
"line": 735,
"column": 53
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Cycle α\nl₁ l₂ : List α\nh : (IsRotated.setoid α) l₁ l₂\nh₁ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₁)\nh₂ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₂)\n_he : h₁ ≍ h₂\ny : α\nhm' : y ∈ Quot.mk (⇑(IsRotated.setoid α)) l₂\nhm : y ∈ Quot.mk (⇑(IsRotated.setoid α)... | [
"α : Type u_1\ninst✝ : DecidableEq α\ns : Cycle α\nl₁ l₂ : List α\nh : (IsRotated.setoid α) l₁ l₂\nh₁ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₁)\nh₂ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₂)\n_he : h₁ ≍ h₂\ny : α\nhm' : y ∈ Quot.mk (⇑(IsRotated.setoid α)) l₂\nhm : y ∈ Quot.mk (⇑(IsRotated.setoid α)) l₁\nhe' : ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.List.Cycle | {
"line": 743,
"column": 58
} | {
"line": 743,
"column": 85
} | {
"line": 743,
"column": 86
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Cycle α\nl₁ l₂ : List α\nh : (IsRotated.setoid α) l₁ l₂\nh₁ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₁)\nh₂ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₂)\n_he : h₁ ≍ h₂\nx y : α\nhxy : x ≍ y\n⊢ y ∈ Quot.mk (⇑(IsRotated.setoid α)) l₁ ↔ y ∈ Quot.mk (⇑(IsRotated.se... | [
"α : Type u_1\ninst✝ : DecidableEq α\ns : Cycle α\nl₁ l₂ : List α\nh : (IsRotated.setoid α) l₁ l₂\nh₁ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₁)\nh₂ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₂)\n_he : h₁ ≍ h₂\nx y : α\nhxy : x ≍ y\n⊢ y ∈ l₁ ↔ y ∈ l₂"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.List.Cycle | {
"line": 745,
"column": 41
} | {
"line": 745,
"column": 52
} | {
"line": 745,
"column": 53
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Cycle α\nl₁ l₂ : List α\nh : (IsRotated.setoid α) l₁ l₂\nh₁ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₁)\nh₂ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₂)\n_he : h₁ ≍ h₂\ny : α\nhm' : y ∈ Quot.mk (⇑(IsRotated.setoid α)) l₂\nhm : y ∈ Quot.mk (⇑(IsRotated.setoid α)... | [
"α : Type u_1\ninst✝ : DecidableEq α\ns : Cycle α\nl₁ l₂ : List α\nh : (IsRotated.setoid α) l₁ l₂\nh₁ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₁)\nh₂ : Nodup (Quot.mk (⇑(IsRotated.setoid α)) l₂)\n_he : h₁ ≍ h₂\ny : α\nhm' : y ∈ Quot.mk (⇑(IsRotated.setoid α)) l₂\nhm : y ∈ Quot.mk (⇑(IsRotated.setoid α)) l₁\nhe' : ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factors | {
"line": 137,
"column": 2
} | {
"line": 137,
"column": 66
} | {
"line": 137,
"column": 67
} | [
{
"pp": "a b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\nh : a.primeFactorsList ~ b.primeFactorsList\n⊢ a = b",
"ppTerm": "?m.9",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"a b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\nh : a.primeFactorsList ~ b.primeFactorsList\n⊢ a = b"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.PrimeFin | {
"line": 77,
"column": 2
} | {
"line": 77,
"column": 13
} | {
"line": 77,
"column": 14
} | [
{
"pp": "a✝ : ℕ\n⊢ a✝ ∈ primeFactors 1 ↔ a✝ ∈ ∅",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"Nat.instMulZeroClass",
"Nat.Prime",
"Dvd.dvd",
"Nat.instOne",
"and_true",
"iff_false",
"congrArg",
"Finset",
... | [
"a✝ : ℕ\n⊢ Prime a✝ → ¬a✝ = 1"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factors | {
"line": 271,
"column": 2
} | {
"line": 271,
"column": 40
} | {
"line": 271,
"column": 41
} | [
{
"pp": "a b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\np : ℕ\n⊢ Prime p ∧ p ∣ a * b ↔ Prime p ∧ (p ∣ a ∨ p ∣ b)",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.Prime",
"Dvd.dvd",
"HMul.hMul",
"id",
"instMulNat",
"_private.Mathlib.Data.Nat.Factors... | [
"a b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\np : ℕ\n⊢ Prime p → (p ∣ a * b ↔ p ∣ a ∨ p ∣ b)"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.GroupTheory.Index | {
"line": 196,
"column": 39
} | {
"line": 196,
"column": 50
} | {
"line": 196,
"column": 51
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nh : a ∉ H ∧ ∀ (b : G), b * a ∈ H ∨ b ∈ H\nb : G\nh' : b * a ∈ H ∧ b ∈ H\n⊢ a ∈ H",
"ppTerm": "?m.61",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"G : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nh : a ∉ H ∧ ∀ (b : G), b * a ∈ H ∨ b ∈ H\nb : G\nh' : b * a ∈ H ∧ b ∈ H\n⊢ a ∈ H"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.GroupTheory.Index | {
"line": 206,
"column": 39
} | {
"line": 206,
"column": 50
} | {
"line": 206,
"column": 51
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nh : a ∉ H ∧ ∀ (b : G), a * b ∈ H ∨ b ∈ H\nb : G\nh' : a * b ∈ H ∧ b ∈ H\n⊢ a ∈ H",
"ppTerm": "?m.61",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"G : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nh : a ∉ H ∧ ∀ (b : G), a * b ∈ H ∨ b ∈ H\nb : G\nh' : a * b ∈ H ∧ b ∈ H\n⊢ a ∈ H"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.GroupTheory.Index | {
"line": 276,
"column": 52
} | {
"line": 276,
"column": 99
} | {
"line": 278,
"column": 0
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\n⊢ H.relIndex ⊥ = 1",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Subgroup.subgroupOf",
"congrArg",
"Membership.mem",
"id",
"Subtype",
"Subgroup",
"instOfNatNat",
"Bot.... | [] | rw [relIndex, subgroupOf_bot_eq_top, index_top] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Index | {
"line": 276,
"column": 52
} | {
"line": 276,
"column": 99
} | {
"line": 278,
"column": 0
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\n⊢ H.relIndex ⊥ = 1",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Subgroup.subgroupOf",
"congrArg",
"Membership.mem",
"id",
"Subtype",
"Subgroup",
"instOfNatNat",
"Bot.... | [] | rw [relIndex, subgroupOf_bot_eq_top, index_top] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Index | {
"line": 276,
"column": 52
} | {
"line": 276,
"column": 99
} | {
"line": 278,
"column": 0
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\n⊢ H.relIndex ⊥ = 1",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Subgroup.subgroupOf",
"congrArg",
"Membership.mem",
"id",
"Subtype",
"Subgroup",
"instOfNatNat",
"Bot.... | [] | rw [relIndex, subgroupOf_bot_eq_top, index_top] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Index | {
"line": 494,
"column": 44
} | {
"line": 494,
"column": 55
} | {
"line": 494,
"column": 56
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nha : ∀ (b : G), b * a ∈ H ∨ b ∈ H\nha' : a ∈ H\nb : G\nh : b * a ∈ H\n⊢ b ∈ H",
"ppTerm": "?m.162",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"G : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nha : ∀ (b : G), b * a ∈ H ∨ b ∈ H\nha' : a ∈ H\nb : G\nh : b * a ∈ H\n⊢ b ∈ H"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.GroupTheory.Index | {
"line": 494,
"column": 44
} | {
"line": 494,
"column": 79
} | {
"line": 494,
"column": 79
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nha : ∀ (b : G), b * a ∈ H ∨ b ∈ H\nha' : a ∈ H\nb : G\nh : b * a ∈ H\n⊢ b ∈ H",
"ppTerm": "?m.162",
"assigned": true,
"usedConstants": [
"mul_inv_cancel_right",
"DivInvMonoid.toInv",
"Subgroup.instSubgroupClass",
... | [] | simpa using mul_mem h (inv_mem ha') | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.GroupTheory.Index | {
"line": 494,
"column": 44
} | {
"line": 494,
"column": 79
} | {
"line": 494,
"column": 79
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nha : ∀ (b : G), b * a ∈ H ∨ b ∈ H\nha' : a ∈ H\nb : G\nh : b * a ∈ H\n⊢ b ∈ H",
"ppTerm": "?m.162",
"assigned": true,
"usedConstants": [
"mul_inv_cancel_right",
"DivInvMonoid.toInv",
"Subgroup.instSubgroupClass",
... | [] | simpa using mul_mem h (inv_mem ha') | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Index | {
"line": 494,
"column": 44
} | {
"line": 494,
"column": 79
} | {
"line": 494,
"column": 79
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nha : ∀ (b : G), b * a ∈ H ∨ b ∈ H\nha' : a ∈ H\nb : G\nh : b * a ∈ H\n⊢ b ∈ H",
"ppTerm": "?m.162",
"assigned": true,
"usedConstants": [
"mul_inv_cancel_right",
"DivInvMonoid.toInv",
"Subgroup.instSubgroupClass",
... | [] | simpa using mul_mem h (inv_mem ha') | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Index | {
"line": 497,
"column": 6
} | {
"line": 497,
"column": 17
} | {
"line": 497,
"column": 18
} | [
{
"pp": "case neg\nG : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nha : ∀ (b : G), b * a ∈ H ∨ b ∈ H\nha' : a ∉ H\nb : G\nh : b * a ∈ H ∧ b ∈ H\n⊢ a ∈ H",
"ppTerm": "?neg✝",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"case neg\nG : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nha : ∀ (b : G), b * a ∈ H ∨ b ∈ H\nha' : a ∉ H\nb : G\nh : b * a ∈ H ∧ b ∈ H\n⊢ a ∈ H"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.GroupTheory.Index | {
"line": 588,
"column": 4
} | {
"line": 588,
"column": 32
} | {
"line": 588,
"column": 33
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\nh : H.index ≠ 0\na : G\nhc : ∀ (x x_1 : ℕ), ¬(x ≠ x_1 ∧ x ≤ H.index ∧ x_1 ≤ H.index ∧ ↑(a ^ x_1) = ↑(a ^ x))\nf : ↑(Set.Icc 0 H.index) → G ⧸ H := fun n ↦ ↑(a ^ ↑n)\nn₁ : ℕ\nh₁ : 0 ≤ n₁\nhle₁ : n₁ ≤ H.index\nn₂ : ℕ\nh₂ : 0 ≤ n₂\nhle₂ : n₂ ≤ H.index\nhe : ↑(... | [
"G : Type u_1\ninst✝ : Group G\nH : Subgroup G\nh : H.index ≠ 0\na : G\nhc : ∀ (x x_1 : ℕ), ¬(x ≠ x_1 ∧ x ≤ H.index ∧ x_1 ≤ H.index ∧ ↑(a ^ x_1) = ↑(a ^ x))\nf : ↑(Set.Icc 0 H.index) → G ⧸ H := fun n ↦ ↑(a ^ ↑n)\nn₁ : ℕ\nh₁ : 0 ≤ n₁\nhle₁ : n₁ ≤ H.index\nn₂ : ℕ\nh₂ : 0 ≤ n₂\nhle₂ : n₂ ≤ H.index\nhe : ↑(a ^ n₁) = ↑(... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.GroupTheory.Index | {
"line": 598,
"column": 2
} | {
"line": 598,
"column": 42
} | {
"line": 598,
"column": 43
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH K : Subgroup G\nh : H.relIndex K ≠ 0\na : G\nha : a ∈ K\nn : ℕ\nhlt : 0 < n\nhle : n ≤ (H.subgroupOf K).index\nhe : ⟨a, ha⟩ ^ n ∈ H.subgroupOf K\n⊢ a ^ n ∈ H ⊓ K",
"ppTerm": "?m.71",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Subgroup.instSu... | [
"G : Type u_1\ninst✝ : Group G\nH K : Subgroup G\nh : H.relIndex K ≠ 0\na : G\nha : a ∈ K\nn : ℕ\nhlt : 0 < n\nhle : n ≤ (H.subgroupOf K).index\nhe : ⟨a, ha⟩ ^ n ∈ H.subgroupOf K\n⊢ a ^ n ∈ H"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.NumberTheory.Divisors | {
"line": 135,
"column": 4
} | {
"line": 135,
"column": 30
} | {
"line": 135,
"column": 31
} | [
{
"pp": "case mpr\na b : ℕ\nhab : a ≠ 0 ∧ b ≠ 0\n⊢ a ∣ a * b ∧ (a ≠ 0 ∧ a ≤ a * b) ∧ a * b / a = b",
"ppTerm": "?mpr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"Nat.instMulZeroClass",
"Dvd.dvd",
"instHDiv",
"HMul.hMul",
"eq_false",
"and_... | [
"case mpr\na b : ℕ\nhab : a ≠ 0 ∧ b ≠ 0\n⊢ a ≤ a * b"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Algebra.Algebra.ZMod | {
"line": 56,
"column": 72
} | {
"line": 61,
"column": 50
} | {
"line": 63,
"column": 0
} | [
{
"pp": "R✝ : Type u_1\ninst✝² : Ring R✝\nn : ℕ\nR : Type u_2\ninst✝¹ : Ring R\ninst✝ : Module (ZMod n) R\nr : ZMod n\nx : R\n⊢ r • 1 * x = r • x ∧ x * r • 1 = r • x",
"ppTerm": "?m.51",
"assigned": true,
"usedConstants": [
"Nat.cast_comm",
"Int.cast",
"NonAssocSemiring.toAddCommMo... | [] | by
obtain _ | n := n
· obtain rfl : ((inferInstance : Module ℤ R)) = ‹_› := Subsingleton.elim _ _
simp [ZMod, Int.cast_comm]
· obtain ⟨r, rfl⟩ := ZMod.natCast_zmod_surjective r
simp [Nat.cast_smul_eq_nsmul, Nat.cast_comm] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Ring.GeomSum | {
"line": 57,
"column": 6
} | {
"line": 57,
"column": 32
} | {
"line": 57,
"column": 33
} | [
{
"pp": "case h₁\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : PartialOrder R\ninst✝ : IsOrderedRing R\nx : R\nhx : x + 1 ≤ 0\nhx0 : x ≤ 0\nn : ℕ\nh : ¬Even n\nih : 1 ≤ ∑ i ∈ range n, x ^ i\n⊢ x * ∑ i ∈ range n, x ^ i ≤ x",
"ppTerm": "?h₁",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
... | [
"case h₁\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : PartialOrder R\ninst✝ : IsOrderedRing R\nx : R\nhx : x + 1 ≤ 0\nhx0 : x ≤ 0\nn : ℕ\nh : ¬Even n\nih : 1 ≤ ∑ i ∈ range n, x ^ i\n⊢ x * ∑ i ∈ range n, x ^ i ≤ x"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Algebra.Order.Ring.GeomSum | {
"line": 89,
"column": 4
} | {
"line": 89,
"column": 30
} | {
"line": 89,
"column": 31
} | [
{
"pp": "case bc\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : PartialOrder R\ninst✝ : IsStrictOrderedRing R\nn✝ : ℕ\nx : R\nhx : x + 1 < 0\nhx0 : x < 0\nn : ℕ\nhmn✝ : 2 ≤ n\nhn' : ¬Even n\nihn : 1 < ∑ i ∈ range n, x ^ i\n⊢ x * ∑ i ∈ range n, x ^ i < x",
"ppTerm": "?bc",
"assigned": false,
"usedConstants... | [
"case bc\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : PartialOrder R\ninst✝ : IsStrictOrderedRing R\nn✝ : ℕ\nx : R\nhx : x + 1 < 0\nhx0 : x < 0\nn : ℕ\nhmn✝ : 2 ≤ n\nhn' : ¬Even n\nihn : 1 < ∑ i ∈ range n, x ^ i\n⊢ x * ∑ i ∈ range n, x ^ i < x"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.ZMod.Basic | {
"line": 507,
"column": 2
} | {
"line": 507,
"column": 37
} | {
"line": 507,
"column": 38
} | [
{
"pp": "a b c : ℕ\n⊢ ↑a = ↑b ↔ a ≡ b [MOD c]",
"ppTerm": "?m.2",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"a b c : ℕ\n⊢ ↑a = ↑b ↔ a ≡ b [MOD c]"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Algebra.Order.Ring.GeomSum | {
"line": 121,
"column": 4
} | {
"line": 121,
"column": 27
} | {
"line": 121,
"column": 28
} | [
{
"pp": "case refine_1\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\nn : ℕ\nx : R\nhn✝ : n ≠ 0\nh : 0 < ∑ i ∈ range n, x ^ i\nhn : Even n\nhx : x + 1 ≤ 0\n⊢ ∑ i ∈ range n, x ^ i ≤ 0",
"ppTerm": "?refine_1",
"assigned": false,
"usedConstants": [],
"usedFVa... | [
"case refine_1\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\nn : ℕ\nx : R\nhn✝ : n ≠ 0\nh : 0 < ∑ i ∈ range n, x ^ i\nhn : Even n\nhx : x + 1 ≤ 0\n⊢ ∑ i ∈ range n, x ^ i ≤ 0"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.NumberTheory.Divisors | {
"line": 485,
"column": 2
} | {
"line": 485,
"column": 17
} | {
"line": 485,
"column": 18
} | [
{
"pp": "n : ℕ\nh : n.properDivisors = {1}\nm : ℕ\nhm : m < n\nhdvd : m ∣ n\n⊢ m = 1",
"ppTerm": "?m.31",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"n : ℕ\nh : n.properDivisors = {1}\nm : ℕ\nhm : m < n\nhdvd : m ∣ n\n⊢ m = 1"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.ZMod.Basic | {
"line": 679,
"column": 6
} | {
"line": 679,
"column": 13
} | {
"line": 679,
"column": 13
} | [
{
"pp": "n : ℕ\na b : ZMod n\n⊢ (a * b).val ≤ a.val * b.val",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"ZMod.commRing",
"congrArg",
"CommSemiring.toSemiring",
"ZMod.val_mul",
"id",
"Nat.instMod",
"instHMod",
... | [
"n : ℕ\na b : ZMod n\n⊢ a.val * b.val % n ≤ a.val * b.val"
] | val_mul | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.ZMod.Basic | {
"line": 684,
"column": 6
} | {
"line": 684,
"column": 13
} | {
"line": 684,
"column": 13
} | [
{
"pp": "n : ℕ\na b : ZMod n\nh : a.val * b.val < n\n⊢ (a * b).val = a.val * b.val",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"ZMod.commRing",
"congrArg",
"CommSemiring.toSemiring",
"ZMod.val_mul",
"id",
"Nat.instM... | [
"n : ℕ\na b : ZMod n\nh : a.val * b.val < n\n⊢ a.val * b.val % n = a.val * b.val"
] | val_mul | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.ZMod.Basic | {
"line": 743,
"column": 4
} | {
"line": 743,
"column": 35
} | {
"line": 743,
"column": 36
} | [
{
"pp": "case inr\nn : ℕ\nhn : n ≠ 1\n⊢ 1⁻¹ = 1",
"ppTerm": "?inr",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"case inr\nn : ℕ\nhn : n ≠ 1\n⊢ 1⁻¹ = 1"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.ZMod.Basic | {
"line": 929,
"column": 6
} | {
"line": 929,
"column": 24
} | {
"line": 929,
"column": 25
} | [
{
"pp": "case mp.zero\n⊢ Subsingleton (ZMod 0) → 0 = 1",
"ppTerm": "?mp.zero",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"Nat.instMulZeroClass",
"Nat.instOne",
"id",
"instOfNatNat",
"Int",
"ZMod",
"zero_ne_one._simp_1",
"Nat.i... | [
"case mp.zero\n⊢ ¬Subsingleton ℤ"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.ZMod.Basic | {
"line": 931,
"column": 6
} | {
"line": 931,
"column": 24
} | {
"line": 931,
"column": 25
} | [
{
"pp": "case mp.succ.succ\nn : ℕ\n⊢ Subsingleton (ZMod (n + 1 + 1)) → n + 1 + 1 = 1",
"ppTerm": "?mp.succ.succ",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"Nat.instMulZeroClass",
"Nat.instOne",
"congrArg",
"Nat.add_eq_zero_iff._simp_1",
"id",
... | [
"case mp.succ.succ\nn : ℕ\n⊢ ¬Subsingleton (Fin (n + 1 + 1))"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.ZMod.Basic | {
"line": 1203,
"column": 2
} | {
"line": 1203,
"column": 51
} | {
"line": 1203,
"column": 52
} | [
{
"pp": "n : ℕ\nS : Type u_1\nG : Type u_2\ninst✝³ : AddCommGroup G\ninst✝² : SetLike S G\ninst✝¹ : AddSubgroupClass S G\nK : S\ninst✝ : Module (ZMod n) G\nx : G\nhx : x ∈ K\n⊢ ∀ (a : ZMod n), a • x ∈ K",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Int.cast",
"Eq.mpr",
... | [
"n : ℕ\nS : Type u_1\nG : Type u_2\ninst✝³ : AddCommGroup G\ninst✝² : SetLike S G\ninst✝¹ : AddSubgroupClass S G\nK : S\ninst✝ : Module (ZMod n) G\nx : G\nhx : x ∈ K\n⊢ ∀ (x_1 : ℤ), x_1 • x ∈ K"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.ZMod.Basic | {
"line": 1229,
"column": 17
} | {
"line": 1229,
"column": 28
} | {
"line": 1229,
"column": 29
} | [
{
"pp": "G : Type u_2\ninst✝² : AddCommGroup G\ninst✝¹ : Nontrivial G\ninst✝ : Module (ZMod 1) G\nx : G\nhx : x ≠ 0\n⊢ x = 0",
"ppTerm": "?m.34",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"G : Type u_2\ninst✝² : AddCommGroup G\ninst✝¹ : Nontrivial G\ninst✝ : Module (ZMod 1) G\nx : G\nhx : x ≠ 0\n⊢ x = 0"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.ZMod.Basic | {
"line": 1247,
"column": 2
} | {
"line": 1247,
"column": 25
} | {
"line": 1247,
"column": 26
} | [
{
"pp": "G : Type u_2\ninst✝¹ : AddCommGroup G\ninst✝ : Module (ZMod 2) G\nx : G\n⊢ x + x = 0",
"ppTerm": "?m.14",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"G : Type u_2\ninst✝¹ : AddCommGroup G\ninst✝ : Module (ZMod 2) G\nx : G\n⊢ x + x = 0"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Digits.Defs | {
"line": 231,
"column": 6
} | {
"line": 231,
"column": 35
} | {
"line": 232,
"column": 4
} | [
{
"pp": "case cons.hxb\nb : ℕ\nh : 1 < b\nd : ℕ\nL : List ℕ\nih : (∀ l ∈ L, l < b) → (∀ (h : L ≠ []), L.getLast h ≠ 0) → b.digits (ofDigits b L) = L\nw₁ : ∀ l ∈ d :: L, l < b\nw₂ : (d :: L).getLast ⋯ ≠ 0\n⊢ d < b",
"ppTerm": "?cons.hxb",
"assigned": true,
"usedConstants": [
"Nat",
"List.... | [] | exact w₁ d List.mem_cons_self | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Nat.Digits.Defs | {
"line": 231,
"column": 6
} | {
"line": 231,
"column": 35
} | {
"line": 232,
"column": 4
} | [
{
"pp": "case cons.hxb\nb : ℕ\nh : 1 < b\nd : ℕ\nL : List ℕ\nih : (∀ l ∈ L, l < b) → (∀ (h : L ≠ []), L.getLast h ≠ 0) → b.digits (ofDigits b L) = L\nw₁ : ∀ l ∈ d :: L, l < b\nw₂ : (d :: L).getLast ⋯ ≠ 0\n⊢ d < b",
"ppTerm": "?cons.hxb",
"assigned": true,
"usedConstants": [
"Nat",
"List.... | [] | exact w₁ d List.mem_cons_self | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Digits.Defs | {
"line": 231,
"column": 6
} | {
"line": 231,
"column": 35
} | {
"line": 232,
"column": 4
} | [
{
"pp": "case cons.hxb\nb : ℕ\nh : 1 < b\nd : ℕ\nL : List ℕ\nih : (∀ l ∈ L, l < b) → (∀ (h : L ≠ []), L.getLast h ≠ 0) → b.digits (ofDigits b L) = L\nw₁ : ∀ l ∈ d :: L, l < b\nw₂ : (d :: L).getLast ⋯ ≠ 0\n⊢ d < b",
"ppTerm": "?cons.hxb",
"assigned": true,
"usedConstants": [
"Nat",
"List.... | [] | exact w₁ d List.mem_cons_self | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.ZMod.Basic | {
"line": 1254,
"column": 2
} | {
"line": 1254,
"column": 26
} | {
"line": 1254,
"column": 27
} | [
{
"pp": "G : Type u_2\ninst✝¹ : AddCommGroup G\ninst✝ : Module (ZMod 2) G\nx y z : G\n⊢ x + y + (y + z) = x + z",
"ppTerm": "?m.24",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"G : Type u_2\ninst✝¹ : AddCommGroup G\ninst✝ : Module (ZMod 2) G\nx y z : G\n⊢ x + y + (y + z) = x + z"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Digits.Defs | {
"line": 235,
"column": 8
} | {
"line": 235,
"column": 19
} | {
"line": 235,
"column": 20
} | [
{
"pp": "case pos\nb : ℕ\nh : 1 < b\nd : ℕ\nih : (∀ l ∈ [], l < b) → (∀ (h : [] ≠ []), [].getLast h ≠ 0) → b.digits (ofDigits b []) = []\nw₁ : ∀ l ∈ [d], l < b\nw₂ : [d].getLast ⋯ ≠ 0\n⊢ d ≠ 0",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"id",
"Ne",
"instOfNatNat",
... | [
"case pos\nb : ℕ\nh : 1 < b\nd : ℕ\nih : (∀ l ∈ [], l < b) → (∀ (h : [] ≠ []), [].getLast h ≠ 0) → b.digits (ofDigits b []) = []\nw₁ : ∀ l ∈ [d], l < b\nw₂ : [d].getLast ⋯ ≠ 0\n⊢ ¬d = 0"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.ZMod.Basic | {
"line": 1285,
"column": 4
} | {
"line": 1285,
"column": 15
} | {
"line": 1285,
"column": 16
} | [
{
"pp": "case refine_1\nm k n : ℕ\nx✝ : ∃ y, n = k + m * y\na : ℕ\nha : n = k + m * a\n⊢ ↑n = ↑k",
"ppTerm": "?refine_1",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"case refine_1\nm k n : ℕ\nx✝ : ∃ y, n = k + m * y\na : ℕ\nha : n = k + m * a\n⊢ ↑n = ↑k"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.ZMod.Basic | {
"line": 1281,
"column": 2
} | {
"line": 1289,
"column": 17
} | {
"line": 1291,
"column": 0
} | [
{
"pp": "m k : ℕ\n⊢ (Set.range fun n ↦ m * n + k) = {n | ↑n = ↑k ∧ k ≤ n}",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"CharP.cast_eq_zero",
"Iff.mpr",
"Set.ext",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"NonAssocSemiring.toAddCommMonoidWithOne",
... | [] | ext n
simp only [Set.mem_range, Set.mem_setOf_eq]
conv => enter [1, 1, y]; rw [add_comm, eq_comm]
refine ⟨fun ⟨a, ha⟩ ↦ ⟨?_, le_iff_exists_add.mpr ⟨_, ha⟩⟩, fun ⟨H₁, H₂⟩ ↦ ?_⟩
· simpa using congr_arg ((↑) : ℕ → ZMod m) ha
· obtain ⟨a, ha⟩ := le_iff_exists_add.mp H₂
simp only [ha, Nat.cast_add, add_eq_left... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ZMod.Basic | {
"line": 1281,
"column": 2
} | {
"line": 1289,
"column": 17
} | {
"line": 1291,
"column": 0
} | [
{
"pp": "m k : ℕ\n⊢ (Set.range fun n ↦ m * n + k) = {n | ↑n = ↑k ∧ k ≤ n}",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"CharP.cast_eq_zero",
"Iff.mpr",
"Set.ext",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"NonAssocSemiring.toAddCommMonoidWithOne",
... | [] | ext n
simp only [Set.mem_range, Set.mem_setOf_eq]
conv => enter [1, 1, y]; rw [add_comm, eq_comm]
refine ⟨fun ⟨a, ha⟩ ↦ ⟨?_, le_iff_exists_add.mpr ⟨_, ha⟩⟩, fun ⟨H₁, H₂⟩ ↦ ?_⟩
· simpa using congr_arg ((↑) : ℕ → ZMod m) ha
· obtain ⟨a, ha⟩ := le_iff_exists_add.mp H₂
simp only [ha, Nat.cast_add, add_eq_left... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.ZMod.Basic | {
"line": 1295,
"column": 19
} | {
"line": 1295,
"column": 49
} | {
"line": 1295,
"column": 50
} | [
{
"pp": "N : ℕ\ninst✝ : NeZero N\nn : ℕ\n⊢ (fun p ↦ p.1.val + N * p.2) ((fun n ↦ (↑n, n / N)) n) = n",
"ppTerm": "?m.32",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"ZMod.commRing",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
... | [
"N : ℕ\ninst✝ : NeZero N\nn : ℕ\n⊢ n % N + N * (n / N) = n"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Digits.Defs | {
"line": 325,
"column": 4
} | {
"line": 326,
"column": 51
} | {
"line": 326,
"column": 52
} | [
{
"pp": "b : ℕ\nhb : 1 < b\nD : ℕ\nL : List ℕ\nih :\n ∀ {L2 : List ℕ}, L.length = L2.length → (∀ l ∈ L, l < b) → (∀ l ∈ L2, l < b) → ofDigits b L = ofDigits b L2 → L = L2\nw1 : ∀ l ∈ D :: L, l < b\nd : ℕ\nl : List ℕ\nw2 : ∀ l_1 ∈ d :: l, l_1 < b\nh : D + b * ofDigits b L = d + b * ofDigits b l\nlen : L.length ... | [
"b : ℕ\nhb : 1 < b\nD : ℕ\nL : List ℕ\nih :\n ∀ {L2 : List ℕ}, L.length = L2.length → (∀ l ∈ L, l < b) → (∀ l ∈ L2, l < b) → ofDigits b L = ofDigits b L2 → L = L2\nw1 : ∀ l ∈ D :: L, l < b\nd : ℕ\nl : List ℕ\nw2 : ∀ l_1 ∈ d :: l, l_1 < b\nh : D + b * ofDigits b L = d + b * ofDigits b l\nlen : L.length = l.length\n... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 217,
"column": 2
} | {
"line": 217,
"column": 13
} | {
"line": 217,
"column": 14
} | [
{
"pp": "p n : ℕ\nhp : 1 < p\nhn : n ≠ 0\n⊢ p.maxPowDvdDiv (p * n) = (padicValNat p n + 1, n.divMaxPow p)",
"ppTerm": "?m.21",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"p n : ℕ\nhp : 1 < p\nhn : n ≠ 0\n⊢ p.maxPowDvdDiv (p * n) = (padicValNat p n + 1, n.divMaxPow p)"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 227,
"column": 2
} | {
"line": 227,
"column": 13
} | {
"line": 227,
"column": 14
} | [
{
"pp": "p : ℕ\nhp : p ≠ 0\nn : ℕ\n⊢ (p * n).divMaxPow p = n.divMaxPow p",
"ppTerm": "?m.9",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"p : ℕ\nhp : p ≠ 0\nn : ℕ\n⊢ (p * n).divMaxPow p = n.divMaxPow p"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 231,
"column": 2
} | {
"line": 231,
"column": 13
} | {
"line": 231,
"column": 14
} | [
{
"pp": "p : ℕ\nhp : 1 < p\nk : ℕ\n⊢ p.maxPowDvdDiv (p ^ k) = (k, 1)",
"ppTerm": "?m.14",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"p : ℕ\nhp : 1 < p\nk : ℕ\n⊢ p.maxPowDvdDiv (p ^ k) = (k, 1)"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 239,
"column": 2
} | {
"line": 239,
"column": 13
} | {
"line": 239,
"column": 14
} | [
{
"pp": "p : ℕ\nhp : p ≠ 0\nk : ℕ\n⊢ (p ^ k).divMaxPow p = 1",
"ppTerm": "?m.11",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"p : ℕ\nhp : p ≠ 0\nk : ℕ\n⊢ (p ^ k).divMaxPow p = 1"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 243,
"column": 2
} | {
"line": 243,
"column": 13
} | {
"line": 243,
"column": 14
} | [
{
"pp": "p : ℕ\nhp : 1 < p\n⊢ p.maxPowDvdDiv p = (1, 1)",
"ppTerm": "?m.12",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"p : ℕ\nhp : 1 < p\n⊢ p.maxPowDvdDiv p = (1, 1)"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 247,
"column": 2
} | {
"line": 247,
"column": 13
} | {
"line": 247,
"column": 14
} | [
{
"pp": "p : ℕ\nhp : 1 < p\n⊢ padicValNat p p = 1",
"ppTerm": "?m.8",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"p : ℕ\nhp : 1 < p\n⊢ padicValNat p p = 1"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 251,
"column": 2
} | {
"line": 251,
"column": 13
} | {
"line": 251,
"column": 14
} | [
{
"pp": "p : ℕ\nhp : p ≠ 0\n⊢ p.divMaxPow p = 1",
"ppTerm": "?m.7",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"p : ℕ\nhp : p ≠ 0\n⊢ p.divMaxPow p = 1"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Digits.Defs | {
"line": 369,
"column": 2
} | {
"line": 377,
"column": 34
} | {
"line": 379,
"column": 0
} | [
{
"pp": "b : ℕ\nl : List ℕ\nhl : ∀ x ∈ l, x < b + 2\n⊢ ofDigits (b + 2) l < (b + 2) ^ l.length",
"ppTerm": "?m.34",
"assigned": true,
"usedConstants": [
"Int.instAddCommGroup",
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"Iff.mpr",
"Mathlib.Tactic.Ring.Common.neg_zero",
"... | [] | induction l with
| nil => simp [ofDigits]
| cons hd tl IH =>
rw [ofDigits, List.length_cons, pow_succ]
have : (ofDigits (b + 2) tl + 1) * (b + 2) ≤ (b + 2) ^ tl.length * (b + 2) :=
mul_le_mul (IH fun x hx => hl _ (List.mem_cons_of_mem _ hx)) (by rfl) (by simp only [zero_le])
(Nat.zero_le _)
... | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Nat.Digits.Defs | {
"line": 369,
"column": 2
} | {
"line": 377,
"column": 34
} | {
"line": 379,
"column": 0
} | [
{
"pp": "b : ℕ\nl : List ℕ\nhl : ∀ x ∈ l, x < b + 2\n⊢ ofDigits (b + 2) l < (b + 2) ^ l.length",
"ppTerm": "?m.34",
"assigned": true,
"usedConstants": [
"Int.instAddCommGroup",
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"Iff.mpr",
"Mathlib.Tactic.Ring.Common.neg_zero",
"... | [] | induction l with
| nil => simp [ofDigits]
| cons hd tl IH =>
rw [ofDigits, List.length_cons, pow_succ]
have : (ofDigits (b + 2) tl + 1) * (b + 2) ≤ (b + 2) ^ tl.length * (b + 2) :=
mul_le_mul (IH fun x hx => hl _ (List.mem_cons_of_mem _ hx)) (by rfl) (by simp only [zero_le])
(Nat.zero_le _)
... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Digits.Defs | {
"line": 369,
"column": 2
} | {
"line": 377,
"column": 34
} | {
"line": 379,
"column": 0
} | [
{
"pp": "b : ℕ\nl : List ℕ\nhl : ∀ x ∈ l, x < b + 2\n⊢ ofDigits (b + 2) l < (b + 2) ^ l.length",
"ppTerm": "?m.34",
"assigned": true,
"usedConstants": [
"Int.instAddCommGroup",
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"Iff.mpr",
"Mathlib.Tactic.Ring.Common.neg_zero",
"... | [] | induction l with
| nil => simp [ofDigits]
| cons hd tl IH =>
rw [ofDigits, List.length_cons, pow_succ]
have : (ofDigits (b + 2) tl + 1) * (b + 2) ≤ (b + 2) ^ tl.length * (b + 2) :=
mul_le_mul (IH fun x hx => hl _ (List.mem_cons_of_mem _ hx)) (by rfl) (by simp only [zero_le])
(Nat.zero_le _)
... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 124,
"column": 2
} | {
"line": 124,
"column": 37
} | {
"line": 124,
"column": 38
} | [
{
"pp": "case inr.inr\nb n : ℕ\nhn : n ≠ 0\nhb : 1 < b\n⊢ (b.digits n).length ≤ (b.digits (n + 1)).length",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"Nat.instMulZeroClass",
"Preorder.toLT",
"Nat.instIsOrderedAddMonoid",
"AddLef... | [
"case inr.inr\nb n : ℕ\nhn : n ≠ 0\nhb : 1 < b\n⊢ log b n ≤ log b (n + 1)"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Digits.Defs | {
"line": 552,
"column": 2
} | {
"line": 552,
"column": 24
} | {
"line": 552,
"column": 25
} | [
{
"pp": "n e : ℕ\n⊢ 0 < e → n < 10 ^ e → n.repr.length ≤ e",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Nat.instMonoid",
"id",
"instOfNatNat",
"String.length_ofList",
"LE.le",
"instLENat",
"NPow.toPow",
"... | [
"n e : ℕ\n⊢ 0 < e → n < 10 ^ e → (toDigits 10 n).length ≤ e"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.NumberTheory.Padics.PadicVal.Defs | {
"line": 84,
"column": 2
} | {
"line": 84,
"column": 17
} | {
"line": 84,
"column": 18
} | [
{
"pp": "case inr.inr\np n : ℕ\nhn₀ : n ≠ 0\nhp₁ : p ≠ 1\n⊢ padicValNat p n = 0 ↔ p = 1 ∨ n = 0 ∨ ¬p ∣ n",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"Dvd.dvd",
"eq_false",
"congrArg",
"id",
"padicValNat",
"instOfNatN... | [
"case inr.inr\np n : ℕ\nhn₀ : n ≠ 0\nhp₁ : p ≠ 1\n⊢ padicValNat p n = 0 ↔ ¬p ∣ n"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 59,
"column": 2
} | {
"line": 59,
"column": 29
} | {
"line": 59,
"column": 30
} | [
{
"pp": "n p : ℕ\npp : Prime p\n⊢ n.factorization p = padicValNat p n",
"ppTerm": "?m.3",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instMulZeroClass",
"Nat.Prime",
"id",
"padicValNat",
"instOfNatNat",
"ite_eq_left_iff._... | [
"n p : ℕ\npp : Prime p\n⊢ ¬Prime p → 0 = padicValNat p n"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 108,
"column": 8
} | {
"line": 108,
"column": 73
} | {
"line": 108,
"column": 74
} | [
{
"pp": "a b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\nh : ∀ (p : ℕ), a.factorization p = b.factorization p\n⊢ a.primeFactorsList ~ b.primeFactorsList",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instMulZeroClass",
"congrArg",
"_pri... | [
"a b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\nh : ∀ (p : ℕ), a.factorization p = b.factorization p\n⊢ ∀ (a_1 : ℕ), a.factorization a_1 = b.factorization a_1"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 211,
"column": 2
} | {
"line": 211,
"column": 32
} | {
"line": 211,
"column": 33
} | [
{
"pp": "n p : ℕ\nhn : n ≠ 0\nhp : Prime p\nh : (p ^ (n.factorization p + 1)).factorization ≤ n.factorization\n⊢ False",
"ppTerm": "?m.31",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"n p : ℕ\nhn : n ≠ 0\nhp : Prime p\nh : (p ^ (n.factorization p + 1)).factorization ≤ n.factorization\n⊢ False"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 244,
"column": 2
} | {
"line": 244,
"column": 95
} | {
"line": 245,
"column": 2
} | [
{
"pp": "case inr\nn : ℕ\nf : ℕ →₀ ℕ\nhf : f ≤ n.factorization\nhn : n ≠ 0\n⊢ (f.prod fun x1 x2 ↦ x1 ^ x2) ∣ n",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.factorization_prod_pow_eq_self_of_le_factorization",
"Finsupp.instLE",
"Nat.instMulZeroClass"... | [
"n : ℕ\nf : ℕ →₀ ℕ\nhf : f ≤ n.factorization\nhn : n ≠ 0\n⊢ (f.prod fun x1 x2 ↦ x1 ^ x2) ≠ 0"
] | rwa [← factorization_le_iff_dvd ?_ hn, factorization_prod_pow_eq_self_of_le_factorization hf] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 81,
"column": 16
} | {
"line": 81,
"column": 60
} | {
"line": 81,
"column": 61
} | [
{
"pp": "p q : ℕ\nhp : Prime p\nh : p.factorization q ≠ 0\n⊢ p = q",
"ppTerm": "?m.6",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"p q : ℕ\nhp : Prime p\nh : p.factorization q ≠ 0\n⊢ p = q"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 110,
"column": 4
} | {
"line": 110,
"column": 61
} | {
"line": 110,
"column": 62
} | [
{
"pp": "n p : ℕ\nhn : n ≠ 0\npp : ¬Prime p\n⊢ 0 < n / p ^ n.factorization p",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"MulOne.toOne",
"Nat.instMulZeroClass",
"instHDiv",
"Monoid.toMulOneClass",
"congrArg",
... | [
"n p : ℕ\nhn : n ≠ 0\npp : ¬Prime p\n⊢ 0 < n"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.RingTheory.Multiplicity | {
"line": 184,
"column": 10
} | {
"line": 184,
"column": 42
} | {
"line": 184,
"column": 43
} | [
{
"pp": "α : Type u_1\ninst✝ : Monoid α\na b : α\nh : ¬FiniteMultiplicity a b\nn : ℕ\n⊢ ∀ (n : ℕ), a ^ n.succ ∣ b",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Dvd.dvd",
"semigroupDvd",
"id",
"NPow.toPow",
"HPow.hPow",
"Nat",
"Monoid.toSemigroup... | [
"α : Type u_1\ninst✝ : Monoid α\na b : α\nh : ¬FiniteMultiplicity a b\nn : ℕ\n⊢ ∀ (n : ℕ), a ^ (n + 1) ∣ b"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 209,
"column": 4
} | {
"line": 211,
"column": 18
} | {
"line": 213,
"column": 0
} | [
{
"pp": "case inr.inr\np n : ℕ\nh : p < 1\n⊢ (p - 1) * ∑ i ∈ range (log p n).succ, n / p ^ i.succ = n - (p.digits n).sum",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"False",
"Nat.instMulZeroClass",
"Nat.instOrd... | [] | simp [lt_one_iff.mp h]
cases n
all_goals simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 209,
"column": 4
} | {
"line": 211,
"column": 18
} | {
"line": 213,
"column": 0
} | [
{
"pp": "case inr.inr\np n : ℕ\nh : p < 1\n⊢ (p - 1) * ∑ i ∈ range (log p n).succ, n / p ^ i.succ = n - (p.digits n).sum",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"False",
"Nat.instMulZeroClass",
"Nat.instOrd... | [] | simp [lt_one_iff.mp h]
cases n
all_goals simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Multiplicity | {
"line": 202,
"column": 4
} | {
"line": 202,
"column": 15
} | {
"line": 202,
"column": 16
} | [
{
"pp": "case succ.isTrue\nα : Type u_1\ninst✝ : Monoid α\na b : α\nn✝ : ℕ\nh✝ : FiniteMultiplicity a b\nhk : n✝ + 1 ≤ Nat.find h✝\n⊢ a ^ (n✝ + 1) ∣ b",
"ppTerm": "?succ.isTrue",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"case succ.isTrue\nα : Type u_1\ninst✝ : Monoid α\na b : α\nn✝ : ℕ\nh✝ : FiniteMultiplicity a b\nhk : n✝ + 1 ≤ Nat.find h✝\n⊢ a ^ (n✝ + 1) ∣ b"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 223,
"column": 6
} | {
"line": 223,
"column": 33
} | {
"line": 224,
"column": 6
} | [
{
"pp": "case bit.false\nn : ℕ\nh : n ≠ 0\nih : digits 2 n = List.map (fun b ↦ bif b then 1 else 0) n.bits\n⊢ digits 2 (bit false n) = List.map (fun b ↦ bif b then 1 else 0) (false :: n.bits)",
"ppTerm": "?bit.false",
"assigned": true,
"usedConstants": [
"cond",
"Nat.bit",
"Eq.mpr"... | [
"case bit.false\nn : ℕ\nh : n ≠ 0\nih : digits 2 n = List.map (fun b ↦ bif b then 1 else 0) n.bits\n⊢ bit false n % 2 :: digits 2 (bit false n / 2) = List.map (fun b ↦ bif b then 1 else 0) (false :: n.bits)",
"case bit.false\nn : ℕ\nh : n ≠ 0\nih : digits 2 n = List.map (fun b ↦ bif b then 1 else 0) n.bits\n⊢ 0 <... | rw [digits_def' one_lt_two] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Multiplicity | {
"line": 229,
"column": 2
} | {
"line": 229,
"column": 20
} | {
"line": 229,
"column": 21
} | [
{
"pp": "α : Type u_1\ninst✝ : Monoid α\na b : α\nhdiv : a ∣ b\nh : multiplicity a b = 0\n⊢ False",
"ppTerm": "?m.14",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"α : Type u_1\ninst✝ : Monoid α\na b : α\nhdiv : a ∣ b\nh : multiplicity a b = 0\n⊢ False"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 261,
"column": 2
} | {
"line": 266,
"column": 72
} | {
"line": 267,
"column": 2
} | [
{
"pp": "case pos\nb n : ℕ\nh : b ≠ 1\nhb : 1 < b\n⊢ (b.digits n).head! = n % b",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"List.head!_mem_self",
"Nat.digits_lt_base",
"congrArg",
"Nat.ofDigits",
"List.head!",
"instI... | [
"case neg\nb n : ℕ\nh : b ≠ 1\nhb : ¬1 < b\n⊢ (b.digits n).head! = n % b"
] | · rcases n with _ | n
· simp
· nth_rw 2 [← Nat.ofDigits_digits b (n + 1)]
rw [Nat.ofDigits_mod_eq_head! _ _]
exact (Nat.mod_eq_of_lt (Nat.digits_lt_base hb <| List.head!_mem_self <|
Nat.digits_ne_nil_iff_ne_zero.mpr <| Nat.succ_ne_zero n)).symm | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.Multiplicity | {
"line": 312,
"column": 4
} | {
"line": 312,
"column": 43
} | {
"line": 312,
"column": 44
} | [
{
"pp": "case neg\nα : Type u_1\ninst✝ : Monoid α\na b : α\nhf : ¬FiniteMultiplicity a b\n⊢ emultiplicity a b = 0 ↔ ¬a ∣ b",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"False",
"Dvd.dvd",
"Classical.not_not._simp_1",
"instTopENat"... | [
"case neg\nα : Type u_1\ninst✝ : Monoid α\na b : α\nhf : ¬FiniteMultiplicity a b\n⊢ a ∣ b"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 259,
"column": 2
} | {
"line": 259,
"column": 23
} | {
"line": 259,
"column": 24
} | [
{
"pp": "x p : ℕ\nhp : Prime p\nhx : p ∣ x\n⊢ x / p / p ^ (x / p).factorization p = x / p ^ x.factorization p",
"ppTerm": "?m.30",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"x p : ℕ\nhp : Prime p\nhx : p ∣ x\n⊢ x / p / p ^ (x / p).factorization p = x / p ^ x.factorization p"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.GroupTheory.OrderOfElement | {
"line": 126,
"column": 46
} | {
"line": 126,
"column": 57
} | {
"line": 126,
"column": 58
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Monoid G\na : G\ninst✝ : IsMulTorsionFree G\nha : a ≠ 1\nn : ℕ\nhn : 0 < n\nhan : a ^ n = 1\n⊢ (fun a ↦ a ^ n) a = (fun a ↦ a ^ n) 1",
"ppTerm": "?m.38",
"assigned": true,
"usedConstants": [
"one_pow",
"Eq.mpr",
"MulOne.toOne",
"Monoid.toMulOne... | [
"G : Type u_1\ninst✝¹ : Monoid G\na : G\ninst✝ : IsMulTorsionFree G\nha : a ≠ 1\nn : ℕ\nhn : 0 < n\nhan : a ^ n = 1\n⊢ a = 1 ∨ n = 0"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 329,
"column": 31
} | {
"line": 329,
"column": 47
} | {
"line": 329,
"column": 48
} | [
{
"pp": "a b : ℕ\nh : ∀ (p : ℕ), a / p ^ a.factorization p ∣ b / p ^ b.factorization p\nhb0 : b ≠ 0\npa : ¬Prime a\n⊢ a ∣ b",
"ppTerm": "?m.65",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"a b : ℕ\nh : ∀ (p : ℕ), a / p ^ a.factorization p ∣ b / p ^ b.factorization p\nhb0 : b ≠ 0\npa : ¬Prime a\n⊢ a ∣ b"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 330,
"column": 31
} | {
"line": 330,
"column": 47
} | {
"line": 330,
"column": 48
} | [
{
"pp": "a b : ℕ\nh : ∀ (p : ℕ), a / p ^ a.factorization p ∣ b / p ^ b.factorization p\nhb0 : b ≠ 0\npa : Prime a\npb : ¬Prime b\n⊢ a ∣ b",
"ppTerm": "?m.83",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"a b : ℕ\nh : ∀ (p : ℕ), a / p ^ a.factorization p ∣ b / p ^ b.factorization p\nhb0 : b ≠ 0\npa : Prime a\npb : ¬Prime b\n⊢ a ∣ b"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 335,
"column": 2
} | {
"line": 335,
"column": 72
} | {
"line": 335,
"column": 73
} | [
{
"pp": "case inr\na b : ℕ\nh : ∀ (p : ℕ), a / p ^ a.factorization p ∣ b / p ^ b.factorization p\nhb0 : b ≠ 0\npa : Prime a\npb : Prime b\nhab : ¬a = b\n⊢ b * a ∣ b",
"ppTerm": "?inr",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"case inr\na b : ℕ\nh : ∀ (p : ℕ), a / p ^ a.factorization p ∣ b / p ^ b.factorization p\nhb0 : b ≠ 0\npa : Prime a\npb : Prime b\nhab : ¬a = b\n⊢ b * a ∣ b"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 354,
"column": 4
} | {
"line": 354,
"column": 42
} | {
"line": 354,
"column": 43
} | [
{
"pp": "case neg\nn : ℕ\nhn : ¬n = 0\n⊢ ∏ p ∈ n.primeFactors, p ∣ n",
"ppTerm": "?neg✝",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"case neg\nn : ℕ\nhn : ¬n = 0\n⊢ ∏ p ∈ n.primeFactors, p ∣ n"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 358,
"column": 70
} | {
"line": 359,
"column": 79
} | {
"line": 360,
"column": 2
} | [
{
"pp": "a b : ℕ\nha_pos : a ≠ 0\nhb_pos : b ≠ 0\nthis : ((a.factorization ⊓ b.factorization).prod fun x1 x2 ↦ x1 ^ x2) = a.gcd b\n⊢ (a.gcd b).factorization = a.factorization ⊓ b.factorization",
"ppTerm": "?m.26",
"assigned": true,
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
"Nat.facto... | [] | by
rw [← this, factorization_prod_pow_eq_self_of_le_factorization inf_le_left] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Multiplicity | {
"line": 566,
"column": 4
} | {
"line": 566,
"column": 22
} | {
"line": 567,
"column": 4
} | [
{
"pp": "case hsucc\nα : Type u_1\ninst✝ : Ring α\np a b : α\nh : ↑(multiplicity p b) < emultiplicity p a\nthis : FiniteMultiplicity p b\n⊢ ¬p ^ (multiplicity p b + 1) ∣ a + b",
"ppTerm": "?hsucc",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"congrArg",
"semigro... | [
"case hsucc\nα : Type u_1\ninst✝ : Ring α\np a b : α\nh : ↑(multiplicity p b) < emultiplicity p a\nthis : FiniteMultiplicity p b\n⊢ ¬p ^ (multiplicity p b + 1) ∣ b",
"case hsucc\nα : Type u_1\ninst✝ : Ring α\np a b : α\nh : ↑(multiplicity p b) < emultiplicity p a\nthis : FiniteMultiplicity p b\n⊢ p ^ (multiplicit... | rw [dvd_add_right] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 440,
"column": 2
} | {
"line": 442,
"column": 7
} | {
"line": 444,
"column": 0
} | [
{
"pp": "b : ℕ\nhb : 1 < b\n⊢ fixedLengthDigits hb 0 = {[]}",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"Nat.instMonoid",
"Nat.ofDigits",
"setOf",
"Set.fintypeLTNat",
"Finset.ext",
"Membership.mem",
... | [] | ext
simp [fixedLengthDigits]
grind | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 440,
"column": 2
} | {
"line": 442,
"column": 7
} | {
"line": 444,
"column": 0
} | [
{
"pp": "b : ℕ\nhb : 1 < b\n⊢ fixedLengthDigits hb 0 = {[]}",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"Nat.instMonoid",
"Nat.ofDigits",
"setOf",
"Set.fintypeLTNat",
"Finset.ext",
"Membership.mem",
... | [] | ext
simp [fixedLengthDigits]
grind | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.OrderOfElement | {
"line": 314,
"column": 34
} | {
"line": 314,
"column": 45
} | {
"line": 314,
"column": 46
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx : G\nn a : ℕ\nhx : x ^ n = 1\nc : ℕ\nh : a ≡ a + c [MOD n]\nhle : a ≤ a + c\n⊢ n ∣ c",
"ppTerm": "?m.63",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"G : Type u_1\ninst✝ : Monoid G\nx : G\nn a : ℕ\nhx : x ^ n = 1\nc : ℕ\nh : a ≡ a + c [MOD n]\nhle : a ≤ a + c\n⊢ n ∣ c"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.GroupTheory.OrderOfElement | {
"line": 314,
"column": 34
} | {
"line": 314,
"column": 45
} | {
"line": 314,
"column": 46
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx : G\nn b : ℕ\nhx : x ^ n = 1\nc : ℕ\nh : b + c ≡ b [MOD n]\nhle : b ≤ b + c\n⊢ n ∣ c",
"ppTerm": "?m.120",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"G : Type u_1\ninst✝ : Monoid G\nx : G\nn b : ℕ\nhx : x ^ n = 1\nc : ℕ\nh : b + c ≡ b [MOD n]\nhle : b ≤ b + c\n⊢ n ∣ c"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 481,
"column": 4
} | {
"line": 481,
"column": 15
} | {
"line": 481,
"column": 16
} | [
{
"pp": "case refine_1\nb : ℕ\nhb : 1 < b\nl d : ℕ\nhd : d < b\nL : List ℕ\nhL : L ∈ fixedLengthDigits hb l\n⊢ (d :: L).length = l + 1",
"ppTerm": "?refine_1",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"id",
"instOfNatNat",
"List.cons",
"instHAdd",
"HAdd.hAdd... | [
"case refine_1\nb : ℕ\nhb : 1 < b\nl d : ℕ\nhd : d < b\nL : List ℕ\nhL : L ∈ fixedLengthDigits hb l\n⊢ L.length = l"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 450,
"column": 84
} | {
"line": 452,
"column": 66
} | {
"line": 454,
"column": 0
} | [
{
"pp": "p a b : ℕ\nhab : a.Coprime b\nhpb : p ∈ b.primeFactorsList\n⊢ (a * b).factorization p = b.factorization p",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.Coprime",
"Nat.instMulZeroClass",
"HMul.hMul",
"CommS... | [] | by
rw [mul_comm]
exact factorization_eq_of_coprime_left (coprime_comm.mp hab) hpb | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Multiplicity | {
"line": 669,
"column": 6
} | {
"line": 669,
"column": 24
} | {
"line": 669,
"column": 25
} | [
{
"pp": "case pos.inl\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : IsCancelMulZero α\na : α\nha : FiniteMultiplicity a a\nv : α\nhv : 1 = a * v\nthis : IsUnit a\n⊢ False",
"ppTerm": "?pos.inl✝",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"case pos.inl\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : IsCancelMulZero α\na : α\nha : FiniteMultiplicity a a\nv : α\nhv : 1 = a * v\nthis : IsUnit a\n⊢ False"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.RingTheory.Multiplicity | {
"line": 670,
"column": 6
} | {
"line": 670,
"column": 17
} | {
"line": 670,
"column": 18
} | [
{
"pp": "case pos.inr\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : IsCancelMulZero α\nv : α\nha : FiniteMultiplicity 0 0\n⊢ False",
"ppTerm": "?pos.inr✝",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"case pos.inr\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : IsCancelMulZero α\nv : α\nha : FiniteMultiplicity 0 0\n⊢ False"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 486,
"column": 2
} | {
"line": 486,
"column": 13
} | {
"line": 486,
"column": 14
} | [
{
"pp": "n : ℕ\nhn : n ≠ 0\n⊢ n = ∏ p, ↑p ^ n.factorization ↑p",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instMulZeroClass",
"Finset.univ",
"congrArg",
"Finset",
"Nat.instMonoid",
"Membership.mem",
... | [
"n : ℕ\nhn : n ≠ 0\n⊢ n = ∏ x ∈ n.primeFactors, x ^ n.factorization x"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.RingTheory.Multiplicity | {
"line": 701,
"column": 4
} | {
"line": 701,
"column": 64
} | {
"line": 701,
"column": 65
} | [
{
"pp": "case neg\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : IsCancelMulZero α\np a b : α\nhp : Prime p\nhfin : ¬FiniteMultiplicity p (a * b)\n⊢ ¬FiniteMultiplicity p a ∨ ¬FiniteMultiplicity p b",
"ppTerm": "?neg✝",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoa... | [
"case neg\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : IsCancelMulZero α\np a b : α\nhp : Prime p\nhfin : ¬FiniteMultiplicity p (a * b)\n⊢ ¬FiniteMultiplicity p a ∨ ¬FiniteMultiplicity p b"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.GroupTheory.OrderOfElement | {
"line": 446,
"column": 2
} | {
"line": 447,
"column": 9
} | {
"line": 447,
"column": 10
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\na : G\nha : IsOfFinOrder a\n⊢ Nat.card ↑↑(powers a) ≤ orderOf a",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Set.fintypeImage._proof_1",
"Eq.mpr",
"Fintype.card_ofFinset",
"Finset.coe_range",
"Monoid.toMulOneClass",
... | [
"G : Type u_1\ninst✝ : Monoid G\na : G\nha : IsOfFinOrder a\n⊢ #(Finset.image (fun x ↦ a ^ x) (Finset.range (orderOf a))) ≤ orderOf a"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.RingTheory.Multiplicity | {
"line": 709,
"column": 25
} | {
"line": 709,
"column": 48
} | {
"line": 709,
"column": 49
} | [
{
"pp": "case insert\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : IsCancelMulZero α\nβ : Type u_3\np : α\nhp : Prime p\nf : β → α\na : β\ns : Finset β\nhas : a ∉ s\nih : emultiplicity p (∏ x ∈ s, f x) = ∑ x ∈ s, emultiplicity p (f x)\n⊢ emultiplicity p (∏ x ∈ insert a s, f x) = ∑ x ∈ insert a s, emulti... | [
"case insert\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : IsCancelMulZero α\nβ : Type u_3\np : α\nhp : Prime p\nf : β → α\na : β\ns : Finset β\nhas : a ∉ s\nih : emultiplicity p (∏ x ∈ s, f x) = ∑ x ∈ s, emultiplicity p (f x)\n⊢ emultiplicity p (f a * ∏ x ∈ s, f x) = emultiplicity p (f a) + emultiplicity p... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.RingTheory.Multiplicity | {
"line": 749,
"column": 24
} | {
"line": 749,
"column": 58
} | {
"line": 749,
"column": 59
} | [
{
"pp": "p a b : ℕ\nhp : p ≠ 1\nhle : multiplicity p a ≤ multiplicity p b\nhab : a.Coprime b\nnh : 0 < multiplicity p a\n⊢ p ∣ a",
"ppTerm": "?m.22",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"p a b : ℕ\nhp : p ≠ 1\nhle : multiplicity p a ≤ multiplicity p b\nhab : a.Coprime b\nnh : 0 < multiplicity p a\n⊢ p ∣ a"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.RingTheory.Multiplicity | {
"line": 750,
"column": 24
} | {
"line": 750,
"column": 58
} | {
"line": 750,
"column": 59
} | [
{
"pp": "p a b : ℕ\nhp : p ≠ 1\nhle : multiplicity p a ≤ multiplicity p b\nhab : a.Coprime b\nnh : 0 < multiplicity p a\nda : p ∣ a\n⊢ p ∣ b",
"ppTerm": "?m.43",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"p a b : ℕ\nhp : p ≠ 1\nhle : multiplicity p a ≤ multiplicity p b\nhab : a.Coprime b\nnh : 0 < multiplicity p a\nda : p ∣ a\n⊢ p ∣ b"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Multiplicity | {
"line": 113,
"column": 8
} | {
"line": 113,
"column": 39
} | {
"line": 114,
"column": 8
} | [
{
"pp": "p : ℕ\nhp : Prime p\nn b : ℕ\nhb : log p (n + 1) < b\n⊢ ↑(∑ i ∈ Ico 1 b, n / p ^ i) + ↑(#({i ∈ Ico 1 b | p ^ i ∣ n + 1})) =\n ↑(∑ i ∈ Ico 1 b, (n / p ^ i + if p ^ i ∣ n + 1 then 1 else 0))",
"ppTerm": "?m.163",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"... | [
"p : ℕ\nhp : Prime p\nn b : ℕ\nhb : log p (n + 1) < b\n⊢ ↑(∑ i ∈ Ico 1 b, n / p ^ i) + ↑(#({i ∈ Ico 1 b | p ^ i ∣ n + 1})) =\n ↑(∑ x ∈ Ico 1 b, n / p ^ x + ↑(#({x ∈ Ico 1 b | p ^ x ∣ n + 1})))"
] | rw [sum_add_distrib, sum_boole] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.OrderOfElement | {
"line": 522,
"column": 2
} | {
"line": 522,
"column": 20
} | {
"line": 523,
"column": 4
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx y : G\nh : Commute x y\nhx : IsOfFinOrder x\nhdvd : ∀ (p : ℕ), Nat.Prime p → p ∣ orderOf y → p * orderOf y ∣ orderOf x\n⊢ orderOf (x * y) = orderOf x",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Monoid.... | [
"G : Type u_1\ninst✝ : Monoid G\nx y : G\nh : Commute x y\nhx : IsOfFinOrder x\nhdvd : ∀ (p : ℕ), Nat.Prime p → p ∣ orderOf y → p * orderOf y ∣ orderOf x\n⊢ orderOf (y * x) = orderOf x"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.