module stringlengths 16 90 | startPos dict | endPos dict | nextStartPos dict | goals listlengths 0 96 | goalsAfter listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 371
values | kind stringclasses 375
values |
|---|---|---|---|---|---|---|---|---|
Mathlib.Algebra.MvPolynomial.Variables | {
"line": 87,
"column": 12
} | {
"line": 87,
"column": 60
} | {
"line": 89,
"column": 0
} | [
{
"pp": "R : Type u\nσ : Type u_1\nr : R\ninst✝ : CommSemiring R\n⊢ (C r).vars = ∅",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Multiset.toFinset",
"Finsupp.instAddZeroClass",
"Eq.mpr",
"Nat.instMulZeroClass",
"congrArg",
"CommSemiring.toSemiring",
... | [] | rw [vars_def, degrees_C, Multiset.toFinset_zero] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MvPolynomial.Variables | {
"line": 87,
"column": 12
} | {
"line": 87,
"column": 60
} | {
"line": 89,
"column": 0
} | [
{
"pp": "R : Type u\nσ : Type u_1\nr : R\ninst✝ : CommSemiring R\n⊢ (C r).vars = ∅",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Multiset.toFinset",
"Finsupp.instAddZeroClass",
"Eq.mpr",
"Nat.instMulZeroClass",
"congrArg",
"CommSemiring.toSemiring",
... | [] | rw [vars_def, degrees_C, Multiset.toFinset_zero] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.MvPolynomial.Degrees | {
"line": 521,
"column": 2
} | {
"line": 521,
"column": 59
} | {
"line": 523,
"column": 0
} | [
{
"pp": "R : Type u\nσ : Type u_1\ninst✝ : CommSemiring R\ns : σ →₀ ℕ\nc : R\nhc : c ≠ 0\n⊢ ((monomial s) c).totalDegree = s.sum fun x e ↦ e",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"Nat.instLattice",
"Lattice.toSemilatticeSup",
"MvPol... | [] | classical simp [totalDegree, support_monomial, if_neg hc] | Lean.Elab.Tactic.evalClassical | Lean.Parser.Tactic.classical |
Mathlib.Algebra.MvPolynomial.Degrees | {
"line": 521,
"column": 2
} | {
"line": 521,
"column": 59
} | {
"line": 523,
"column": 0
} | [
{
"pp": "R : Type u\nσ : Type u_1\ninst✝ : CommSemiring R\ns : σ →₀ ℕ\nc : R\nhc : c ≠ 0\n⊢ ((monomial s) c).totalDegree = s.sum fun x e ↦ e",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"Nat.instLattice",
"Lattice.toSemilatticeSup",
"MvPol... | [] | classical simp [totalDegree, support_monomial, if_neg hc] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MvPolynomial.Degrees | {
"line": 521,
"column": 2
} | {
"line": 521,
"column": 59
} | {
"line": 523,
"column": 0
} | [
{
"pp": "R : Type u\nσ : Type u_1\ninst✝ : CommSemiring R\ns : σ →₀ ℕ\nc : R\nhc : c ≠ 0\n⊢ ((monomial s) c).totalDegree = s.sum fun x e ↦ e",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"Nat.instLattice",
"Lattice.toSemilatticeSup",
"MvPol... | [] | classical simp [totalDegree, support_monomial, if_neg hc] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Finsupp.Fin | {
"line": 32,
"column": 6
} | {
"line": 32,
"column": 44
} | {
"line": 32,
"column": 45
} | [
{
"pp": "M : Type u_1\nN : Type u_2\ninst✝¹ : Zero M\ninst✝ : AddCommMonoid N\nn : ℕ\nσ : Fin n →₀ M\ni : M\nf : Fin (n + 1) → M → N\nh : ∀ (x : Fin (n + 1)), f x 0 = 0\n⊢ (cons i σ).sum f = f 0 i + σ.sum (Fin.tail f)",
"ppTerm": "?m.36",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLi... | [
"M : Type u_1\nN : Type u_2\ninst✝¹ : Zero M\ninst✝ : AddCommMonoid N\nn : ℕ\nσ : Fin n →₀ M\ni : M\nf : Fin (n + 1) → M → N\nh : ∀ (x : Fin (n + 1)), f x 0 = 0\n⊢ ∑ i_1, f i_1 ((cons i σ) i_1) = f 0 i + σ.sum (Fin.tail f)"
] | sum_fintype _ _ (fun _ => by apply h), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.MvPolynomial.Variables | {
"line": 220,
"column": 52
} | {
"line": 221,
"column": 52
} | {
"line": 223,
"column": 0
} | [
{
"pp": "R : Type u\nσ : Type u_1\ninst✝ : CommSemiring R\ni : σ\ne : ℕ\nr : R\nhe : e ≠ 0\nhr : r ≠ 0\n⊢ ((monomial (Finsupp.single i e)) r).vars = {i}",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instMulZeroClass",
"Finsupp.support_single",
"Semi... | [] | by
rw [vars_monomial hr, Finsupp.support_single _ he] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Degree.Monomial | {
"line": 36,
"column": 4
} | {
"line": 36,
"column": 80
} | {
"line": 37,
"column": 4
} | [
{
"pp": "case succ\nR : Type u\ninst✝ : Semiring R\np : R[X]\nn : ℕ\nhf : p.natDegree ≤ n + 1\nhn : p.coeff (n + 1) = 0\nh : p.natDegree = n.succ\n⊢ False",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"Nat.succ_eq_add_one",
"Polynomial.coeff_natDegree",
"congrArg",
... | [
"case succ\nR : Type u\ninst✝ : Semiring R\np : R[X]\nn : ℕ\nhf : p.natDegree ≤ n + 1\nhn : p = 0\nh : p.natDegree = n.succ\n⊢ False"
] | rw [← Nat.succ_eq_add_one, ← h, coeff_natDegree, leadingCoeff_eq_zero] at hn | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Polynomial.Degree.Lemmas | {
"line": 56,
"column": 68
} | {
"line": 56,
"column": 96
} | {
"line": 57,
"column": 14
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np q : R[X]\nthis : DecidableEq R := Classical.decEq R\nh0 : ¬p.comp q = 0\nn : ℕ\nhn : n ∈ p.support\n⊢ ↑(C (p.coeff n)).natDegree + n • q.degree ≤ ↑(C (p.coeff n)).natDegree + n • ↑q.natDegree",
"ppTerm": "?m.196",
"assigned": true,
"usedConstants": [
... | [] | by grw [degree_le_natDegree] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Degree.TrailingDegree | {
"line": 155,
"column": 21
} | {
"line": 155,
"column": 62
} | {
"line": 155,
"column": 62
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np : R[X]\nh : p.coeff 0 ≠ 0\n⊢ p.coeff p.natTrailingDegree = p.coeff 0",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"congrArg",
"Polynomial.natTrailingDegree_eq_zero",
"id",
"Ne",
"in... | [
"R : Type u\ninst✝ : Semiring R\np : R[X]\nh : p.coeff 0 ≠ 0\n⊢ p.coeff 0 = p.coeff 0"
] | (natTrailingDegree_eq_zero.mpr <| .inr h) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Degree.TrailingDegree | {
"line": 211,
"column": 2
} | {
"line": 211,
"column": 58
} | {
"line": 213,
"column": 0
} | [
{
"pp": "R : Type u\na : R\ninst✝ : Semiring R\nn : ℕ\nha : a ≠ 0\n⊢ (C a * X ^ n).trailingDegree = ↑n",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Semiring.toModule",
"HMul.hMul",
"ENat.instNatCast",
"congrArg",
"Line... | [] | rw [C_mul_X_pow_eq_monomial, trailingDegree_monomial ha] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Polynomial.Degree.TrailingDegree | {
"line": 211,
"column": 2
} | {
"line": 211,
"column": 58
} | {
"line": 213,
"column": 0
} | [
{
"pp": "R : Type u\na : R\ninst✝ : Semiring R\nn : ℕ\nha : a ≠ 0\n⊢ (C a * X ^ n).trailingDegree = ↑n",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Semiring.toModule",
"HMul.hMul",
"ENat.instNatCast",
"congrArg",
"Line... | [] | rw [C_mul_X_pow_eq_monomial, trailingDegree_monomial ha] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Degree.TrailingDegree | {
"line": 211,
"column": 2
} | {
"line": 211,
"column": 58
} | {
"line": 213,
"column": 0
} | [
{
"pp": "R : Type u\na : R\ninst✝ : Semiring R\nn : ℕ\nha : a ≠ 0\n⊢ (C a * X ^ n).trailingDegree = ↑n",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Semiring.toModule",
"HMul.hMul",
"ENat.instNatCast",
"congrArg",
"Line... | [] | rw [C_mul_X_pow_eq_monomial, trailingDegree_monomial ha] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Degree.TrailingDegree | {
"line": 317,
"column": 6
} | {
"line": 317,
"column": 22
} | {
"line": 317,
"column": 22
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np q : R[X]\ni j : ℕ\nh₁ : (i, j) ∈ antidiagonal (p.natTrailingDegree + q.natTrailingDegree)\nh₂ : (i, j) ≠ (p.natTrailingDegree, q.natTrailingDegree)\n⊢ p.coeff (i, j).1 * q.coeff (i, j).2 = 0",
"ppTerm": "?m.68",
"assigned": true,
"usedConstants": [
"A... | [
"R : Type u\ninst✝ : Semiring R\np q : R[X]\ni j : ℕ\nh₁ : (i, j).1 + (i, j).2 = p.natTrailingDegree + q.natTrailingDegree\nh₂ : (i, j) ≠ (p.natTrailingDegree, q.natTrailingDegree)\n⊢ p.coeff (i, j).1 * q.coeff (i, j).2 = 0"
] | mem_antidiagonal | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Degree.TrailingDegree | {
"line": 328,
"column": 2
} | {
"line": 328,
"column": 75
} | {
"line": 329,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np q : R[X]\nh : p.trailingCoeff * q.trailingCoeff ≠ 0\nhp : p ≠ 0\n⊢ (p * q).trailingDegree = p.trailingDegree + q.trailingDegree",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"MulZeroClass.toMul",
"c... | [
"R : Type u\ninst✝ : Semiring R\np q : R[X]\nh : p.trailingCoeff * q.trailingCoeff ≠ 0\nhp : p ≠ 0\nhq : q ≠ 0\n⊢ (p * q).trailingDegree = p.trailingDegree + q.trailingDegree"
] | have hq : q ≠ 0 := fun hq => h (by rw [hq, trailingCoeff_zero, mul_zero]) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Polynomial.Degree.TrailingDegree | {
"line": 339,
"column": 2
} | {
"line": 339,
"column": 75
} | {
"line": 340,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np q : R[X]\nh : p.trailingCoeff * q.trailingCoeff ≠ 0\nhp : p ≠ 0\n⊢ (p * q).natTrailingDegree = p.natTrailingDegree + q.natTrailingDegree",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"MulZeroClass.toMul",... | [
"R : Type u\ninst✝ : Semiring R\np q : R[X]\nh : p.trailingCoeff * q.trailingCoeff ≠ 0\nhp : p ≠ 0\nhq : q ≠ 0\n⊢ (p * q).natTrailingDegree = p.natTrailingDegree + q.natTrailingDegree"
] | have hq : q ≠ 0 := fun hq => h (by rw [hq, trailingCoeff_zero, mul_zero]) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Polynomial.Degree.TrailingDegree | {
"line": 431,
"column": 12
} | {
"line": 431,
"column": 24
} | {
"line": 431,
"column": 24
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np : R[X]\nn : ℕ∞\nh : p.trailingDegree < n\nh₀ : p = 0\n⊢ n ≤ p.trailingDegree",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"instTopENat",
"congrArg",
"le_top._simp_2",
"Preorder.toLE",
"instPreorderENat",
"LE.... | [] | by simp [h₀] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.EraseLead | {
"line": 283,
"column": 2
} | {
"line": 284,
"column": 74
} | {
"line": 286,
"column": 2
} | [
{
"pp": "case neg\nR : Type u_2\ninst✝² : Ring R\ninst✝¹ : NoZeroDivisors R\ninst✝ : Nontrivial R\nx : R\nP : R[X]\nhx : x ≠ 0\nh : P.nextCoeff = 0\nhp : ¬P = 0\nhe : ¬P.eraseLead = 0\n⊢ ((X - C x) * P).eraseLead.eraseLead = (X - C x) * P.eraseLead",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstan... | [
"case neg\nR : Type u_2\ninst✝² : Ring R\ninst✝¹ : NoZeroDivisors R\ninst✝ : Nontrivial R\nx : R\nP : R[X]\nhx : x ≠ 0\nh : P.nextCoeff = 0\nhp : ¬P = 0\nhe : ¬P.eraseLead = 0\nh₁ : ((X - C x) * P).natDegree = P.natDegree + 1\n⊢ ((X - C x) * P).eraseLead.eraseLead = (X - C x) * P.eraseLead"
] | have h₁ : ((X - C x) * P).natDegree = P.natDegree + 1 := by
rw [natDegree_mul (X_sub_C_ne_zero x) hp, natDegree_X_sub_C, add_comm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Polynomial.EraseLead | {
"line": 305,
"column": 25
} | {
"line": 305,
"column": 34
} | {
"line": 305,
"column": 35
} | [
{
"pp": "case neg.inl.succ\nR : Type u_2\ninst✝² : Ring R\ninst✝¹ : NoZeroDivisors R\ninst✝ : Nontrivial R\nx : R\nP : R[X]\nhx : x ≠ 0\nh : P.nextCoeff = 0\nhp : ¬P = 0\nhe : ¬P.eraseLead = 0\nh₁ : ((X - C x) * P).natDegree = P.natDegree + 1\ndP : ℕ\nhdP : P.natDegree = dP + 2\nh₂ : ((X - C x) * P).nextCoeff ≠... | [
"case neg.inl.succ\nR : Type u_2\ninst✝² : Ring R\ninst✝¹ : NoZeroDivisors R\ninst✝ : Nontrivial R\nx : R\nP : R[X]\nhx : x ≠ 0\nh : P.nextCoeff = 0\nhp : ¬P = 0\nhe : ¬P.eraseLead = 0\nh₁ : ((X - C x) * P).natDegree = P.natDegree + 1\ndP : ℕ\nhdP : P.natDegree = dP + 2\nh₂ : ((X - C x) * P).nextCoeff ≠ 0\nn : ℕ\nh... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Degree.Lemmas | {
"line": 215,
"column": 6
} | {
"line": 220,
"column": 76
} | {
"line": 221,
"column": 6
} | [
{
"pp": "case pos.refine_1\nR : Type u\nS : Type v\ninst✝ : Semiring R\nf : S → R[X]\ns : Finset S\nh : {i | i ∈ s ∧ f i ≠ 0}.Pairwise (Ne on natDegree ∘ f)\nx : S\nhx : x ∈ s\nhx' : f x ≠ 0\nhs : s.Nonempty\n⊢ (s.sup' hs fun i ↦ (f i).degree) ≤ s.sup' hs (WithBot.some ∘ fun i ↦ (f i).natDegree)",
"ppTerm":... | [
"case pos.refine_2\nR : Type u\nS : Type v\ninst✝ : Semiring R\nf : S → R[X]\ns : Finset S\nh : {i | i ∈ s ∧ f i ≠ 0}.Pairwise (Ne on natDegree ∘ f)\nx : S\nhx : x ∈ s\nhx' : f x ≠ 0\nhs : s.Nonempty\n⊢ s.sup' hs (WithBot.some ∘ fun i ↦ (f i).natDegree) ≤ s.sup' hs fun i ↦ (f i).degree"
] | · rw [Finset.sup'_le_iff]
intro b hb
by_cases hb' : f b = 0
· simpa [hb'] using! hs
rw [degree_eq_natDegree hb', Nat.cast_withBot]
exact Finset.le_sup' (fun i : S => (natDegree (f i) : WithBot ℕ)) hb | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Polynomial.Reverse | {
"line": 162,
"column": 30
} | {
"line": 162,
"column": 39
} | {
"line": 162,
"column": 40
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝ : Semiring R\nN O : ℕ\nf : R[X]\nCf : #f.support ≤ Nat.succ 0\nNf : f.natDegree ≤ N\ncg : ℕ\nhcg : ∀ (g : R[X]), #g.support ≤ cg.succ → g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g\ng : R[X]\nCg : #g.support ≤ (cg + 1).succ\nOg : g.natDegree ≤ O\ng... | [
"case pos\nR : Type u_1\ninst✝ : Semiring R\nN O : ℕ\nf : R[X]\nCf : #f.support ≤ Nat.succ 0\nNf : f.natDegree ≤ N\ncg : ℕ\nhcg : ∀ (g : R[X]), #g.support ≤ cg.succ → g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g\ng : R[X]\nCg : #g.support ≤ (cg + 1).succ\nOg : g.natDegree ≤ O\ng0 : g = 0\n⊢... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Reverse | {
"line": 162,
"column": 40
} | {
"line": 162,
"column": 49
} | {
"line": 162,
"column": 50
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝ : Semiring R\nN O : ℕ\nf : R[X]\nCf : #f.support ≤ Nat.succ 0\nNf : f.natDegree ≤ N\ncg : ℕ\nhcg : ∀ (g : R[X]), #g.support ≤ cg.succ → g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g\ng : R[X]\nCg : #g.support ≤ (cg + 1).succ\nOg : g.natDegree ≤ O\ng... | [
"case pos\nR : Type u_1\ninst✝ : Semiring R\nN O : ℕ\nf : R[X]\nCf : #f.support ≤ Nat.succ 0\nNf : f.natDegree ≤ N\ncg : ℕ\nhcg : ∀ (g : R[X]), #g.support ≤ cg.succ → g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g\ng : R[X]\nCg : #g.support ≤ (cg + 1).succ\nOg : g.natDegree ≤ O\ng0 : g = 0\n⊢... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Reverse | {
"line": 163,
"column": 41
} | {
"line": 163,
"column": 49
} | {
"line": 163,
"column": 50
} | [
{
"pp": "case neg\nR : Type u_1\ninst✝ : Semiring R\nN O : ℕ\nf : R[X]\nCf : #f.support ≤ Nat.succ 0\nNf : f.natDegree ≤ N\ncg : ℕ\nhcg : ∀ (g : R[X]), #g.support ≤ cg.succ → g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g\ng : R[X]\nCg : #g.support ≤ (cg + 1).succ\nOg : g.natDegree ≤ O\ng... | [
"case neg\nR : Type u_1\ninst✝ : Semiring R\nN O : ℕ\nf : R[X]\nCf : #f.support ≤ Nat.succ 0\nNf : f.natDegree ≤ N\ncg : ℕ\nhcg : ∀ (g : R[X]), #g.support ≤ cg.succ → g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g\ng : R[X]\nCg : #g.support ≤ (cg + 1).succ\nOg : g.natDegree ≤ O\ng0 : ¬g = 0\n... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Reverse | {
"line": 163,
"column": 76
} | {
"line": 163,
"column": 84
} | {
"line": 163,
"column": 85
} | [
{
"pp": "case neg\nR : Type u_1\ninst✝ : Semiring R\nN O : ℕ\nf : R[X]\nCf : #f.support ≤ Nat.succ 0\nNf : f.natDegree ≤ N\ncg : ℕ\nhcg : ∀ (g : R[X]), #g.support ≤ cg.succ → g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g\ng : R[X]\nCg : #g.support ≤ (cg + 1).succ\nOg : g.natDegree ≤ O\ng... | [
"case neg\nR : Type u_1\ninst✝ : Semiring R\nN O : ℕ\nf : R[X]\nCf : #f.support ≤ Nat.succ 0\nNf : f.natDegree ≤ N\ncg : ℕ\nhcg : ∀ (g : R[X]), #g.support ≤ cg.succ → g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g\ng : R[X]\nCg : #g.support ≤ (cg + 1).succ\nOg : g.natDegree ≤ O\ng0 : ¬g = 0\n... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Degree.Lemmas | {
"line": 291,
"column": 2
} | {
"line": 291,
"column": 38
} | {
"line": 293,
"column": 0
} | [
{
"pp": "R : Type u\nS : Type v\ninst✝¹ : Semiring R\ninst✝ : Semiring S\nf : R →+* S\nhf : Function.Injective ⇑f\np : R[X]\n⊢ (map f p).degree = p.degree",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"RingHom.instRingHomClass",
"WithBot",
"congrArg",
"_private.Ma... | [] | simp [hf, map_ne_zero_iff, ne_or_eq] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Polynomial.Degree.Lemmas | {
"line": 291,
"column": 2
} | {
"line": 291,
"column": 38
} | {
"line": 293,
"column": 0
} | [
{
"pp": "R : Type u\nS : Type v\ninst✝¹ : Semiring R\ninst✝ : Semiring S\nf : R →+* S\nhf : Function.Injective ⇑f\np : R[X]\n⊢ (map f p).degree = p.degree",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"RingHom.instRingHomClass",
"WithBot",
"congrArg",
"_private.Ma... | [] | simp [hf, map_ne_zero_iff, ne_or_eq] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Degree.Lemmas | {
"line": 291,
"column": 2
} | {
"line": 291,
"column": 38
} | {
"line": 293,
"column": 0
} | [
{
"pp": "R : Type u\nS : Type v\ninst✝¹ : Semiring R\ninst✝ : Semiring S\nf : R →+* S\nhf : Function.Injective ⇑f\np : R[X]\n⊢ (map f p).degree = p.degree",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"RingHom.instRingHomClass",
"WithBot",
"congrArg",
"_private.Ma... | [] | simp [hf, map_ne_zero_iff, ne_or_eq] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Degree.Lemmas | {
"line": 424,
"column": 2
} | {
"line": 425,
"column": 59
} | {
"line": 426,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝¹ : Semiring R\ninst✝ : NoZeroDivisors R\np q : R[X]\nh : p.comp q = 0\n⊢ p = 0 ∨ eval (q.coeff 0) p = 0 ∧ q = C (q.coeff 0)",
"ppTerm": "?m.34",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Nat.instMulZeroClass",
... | [
"R : Type u\ninst✝¹ : Semiring R\ninst✝ : NoZeroDivisors R\np q : R[X]\nh : p.comp q = 0\nkey : p.natDegree = 0 ∨ q.natDegree = 0\n⊢ p = 0 ∨ eval (q.coeff 0) p = 0 ∧ q = C (q.coeff 0)"
] | have key : p.natDegree = 0 ∨ q.natDegree = 0 := by
rw [← mul_eq_zero, ← natDegree_comp, h, natDegree_zero] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Polynomial.Reverse | {
"line": 283,
"column": 12
} | {
"line": 283,
"column": 21
} | {
"line": 283,
"column": 22
} | [
{
"pp": "case pos\nR : Type u_2\ninst✝¹ : Semiring R\ninst✝ : NoZeroDivisors R\nf g : R[X]\nf0 : ¬f = 0\ng0 : g = 0\n⊢ (f * 0).reverse = f.reverse * reverse 0",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
... | [
"case pos\nR : Type u_2\ninst✝¹ : Semiring R\ninst✝ : NoZeroDivisors R\nf g : R[X]\nf0 : ¬f = 0\ng0 : g = 0\n⊢ reverse 0 = f.reverse * reverse 0"
] | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.EraseLead | {
"line": 428,
"column": 10
} | {
"line": 428,
"column": 40
} | {
"line": 428,
"column": 40
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝ : Semiring R\nn : ℕ\nhn : ∀ {f : R[X]}, #f.support = n → ∃ k x, ∃ (_ : StrictMono k) (_ : ∀ (i : Fin n), x i ≠ 0), f = ∑ i, C (x i) * X ^ k i\nf : R[X]\nh : #f.support = n + 1\nk : Fin n → ℕ\nx : Fin n → R\nhk : StrictMono k\nhx : ∀ (i : Fin n), x i ≠ 0\nhf : f.eraseLead =... | [
"case pos\nR : Type u_1\ninst✝ : Semiring R\nn : ℕ\nhn : ∀ {f : R[X]}, #f.support = n → ∃ k x, ∃ (_ : StrictMono k) (_ : ∀ (i : Fin n), x i ≠ 0), f = ∑ i, C (x i) * X ^ k i\nf : R[X]\nh : #f.support = n + 1\nk : Fin n → ℕ\nx : Fin n → R\nhk : StrictMono k\nhx : ∀ (i : Fin n), x i ≠ 0\nhf : f.eraseLead = ∑ i, C (x i... | ← Fin.castSucc_lt_castSucc_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.MvPolynomial.Equiv | {
"line": 573,
"column": 2
} | {
"line": 574,
"column": 16
} | {
"line": 576,
"column": 0
} | [
{
"pp": "R : Type u\nσ : Type u_1\ninst✝ : CommSemiring R\np : MvPolynomial (Option σ) R\nm : ℕ\nd : σ →₀ ℕ\n⊢ coeff d (((optionEquivLeft R σ) p).coeff m) = coeff (optionElim m d) p",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.inst... | [] | rw [← optionEquivLeft_coeff_some_coeff_none]
congr <;> simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MvPolynomial.Equiv | {
"line": 573,
"column": 2
} | {
"line": 574,
"column": 16
} | {
"line": 576,
"column": 0
} | [
{
"pp": "R : Type u\nσ : Type u_1\ninst✝ : CommSemiring R\np : MvPolynomial (Option σ) R\nm : ℕ\nd : σ →₀ ℕ\n⊢ coeff d (((optionEquivLeft R σ) p).coeff m) = coeff (optionElim m d) p",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.inst... | [] | rw [← optionEquivLeft_coeff_some_coeff_none]
congr <;> simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Monic | {
"line": 281,
"column": 2
} | {
"line": 281,
"column": 99
} | {
"line": 283,
"column": 0
} | [
{
"pp": "case refine_2\nR : Type u\nι : Type y\ninst✝ : CommSemiring R\nt✝ : Multiset ι\nf : ι → R[X]\na : ι\nt : Multiset ι\nih : (∀ i ∈ t, (f i).Monic) → (Multiset.map f t).prod.Monic\nht : ∀ i ∈ a ::ₘ t, (f i).Monic\n⊢ (f a * (Multiset.map f t).prod).Monic",
"ppTerm": "?refine_2",
"assigned": true,
... | [] | exact (ht _ (Multiset.mem_cons_self _ _)).mul (ih fun _ hi => ht _ (Multiset.mem_cons_of_mem hi)) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Polynomial.Monic | {
"line": 303,
"column": 4
} | {
"line": 303,
"column": 28
} | {
"line": 304,
"column": 2
} | [
{
"pp": "case refine_1\nR : Type u\nι : Type y\ninst✝ : CommSemiring R\nt : Multiset ι\nf : ι → R[X]\n⊢ (C 1).nextCoeff = 0",
"ppTerm": "?refine_1",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithOne",
"congrArg",
"Co... | [] | rw [nextCoeff_C_eq_zero] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Polynomial.EraseLead | {
"line": 474,
"column": 2
} | {
"line": 479,
"column": 7
} | {
"line": 480,
"column": 2
} | [
{
"pp": "case refine_1\nR : Type u_1\ninst✝ : Semiring R\nf : R[X]\nh : #f.support = 3\n⊢ ∃ k m n,\n ∃ (_ : k < m) (_ : m < n),\n ∃ x y z, ∃ (_ : x ≠ 0) (_ : y ≠ 0) (_ : z ≠ 0), f = C x * X ^ k + C y * X ^ m + C z * X ^ n",
"ppTerm": "?refine_1",
"assigned": true,
"usedConstants": [
"E... | [
"case refine_2\nR : Type u_1\ninst✝ : Semiring R\nf : R[X]\n⊢ (∃ k m n,\n ∃ (_ : k < m) (_ : m < n),\n ∃ x y z, ∃ (_ : x ≠ 0) (_ : y ≠ 0) (_ : z ≠ 0), f = C x * X ^ k + C y * X ^ m + C z * X ^ n) →\n #f.support = 3"
] | · obtain ⟨k, x, hk, hx, rfl⟩ := card_support_eq.mp h
refine
⟨k 0, k 1, k 2, hk Nat.zero_lt_one, hk (Nat.lt_succ_self 1), x 0, x 1, x 2, hx 0, hx 1, hx 2,
?_⟩
rw [Fin.sum_univ_castSucc, Fin.sum_univ_castSucc, Fin.sum_univ_one]
rfl | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 196,
"column": 17
} | {
"line": 196,
"column": 28
} | {
"line": 196,
"column": 28
} | [
{
"pp": "case pos\nR : Type u\ninst✝ : Semiring R\ns : Set R[X]\np : R[X]\nhs : s.Nonempty\nhp : p ∈ Submodule.span R s\nh : ∀ p' ∈ s, p'.degree < degree 0\nhp_zero : p = 0\n⊢ False",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"WithBot",
"Preorder.toLT",
"congrArg",
... | [
"case pos\nR : Type u\ninst✝ : Semiring R\ns : Set R[X]\np : R[X]\nhs : s.Nonempty\nhp : p ∈ Submodule.span R s\nh : ∀ p' ∈ s, p'.degree < ⊥\nhp_zero : p = 0\n⊢ False"
] | degree_zero | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 219,
"column": 2
} | {
"line": 219,
"column": 29
} | {
"line": 220,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\ns : Set R[X]\ns_fin : s.Finite\n⊢ ∃ n, Submodule.span R s ≤ degreeLE R ↑n",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Submodule",
"WithBot",
"Semiring.toModule",
"PartialOrder.toPreorder",
"WithBot.instNatCast",
... | [
"case pos\nR : Type u\ninst✝ : Semiring R\ns : Set R[X]\ns_fin : s.Finite\ns_emp : s.Nonempty\n⊢ ∃ n, Submodule.span R s ≤ degreeLE R ↑n",
"case neg\nR : Type u\ninst✝ : Semiring R\ns : Set R[X]\ns_fin : s.Finite\ns_emp : ¬s.Nonempty\n⊢ ∃ n, Submodule.span R s ≤ degreeLE R ↑n"
] | by_cases s_emp : s.Nonempty | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Algebra.Polynomial.Monic | {
"line": 569,
"column": 4
} | {
"line": 574,
"column": 8
} | {
"line": 575,
"column": 2
} | [
{
"pp": "case mp\nR : Type u\ninst✝ : Semiring R\np : R[X]\nh : IsUnit p.leadingCoeff\nq : R[X]\n⊢ q * p = 0 → q = 0",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Units.val",
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Semigrou... | [] | intro hp
replace hp := congr_arg (· * C ↑h.unit⁻¹) hp
simp only [zero_mul] at hp
rwa [mul_assoc, Monic.mul_left_eq_zero_iff] at hp
refine monic_mul_C_of_leadingCoeff_mul_eq_one ?_
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Monic | {
"line": 569,
"column": 4
} | {
"line": 574,
"column": 8
} | {
"line": 575,
"column": 2
} | [
{
"pp": "case mp\nR : Type u\ninst✝ : Semiring R\np : R[X]\nh : IsUnit p.leadingCoeff\nq : R[X]\n⊢ q * p = 0 → q = 0",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Units.val",
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Semigrou... | [] | intro hp
replace hp := congr_arg (· * C ↑h.unit⁻¹) hp
simp only [zero_mul] at hp
rwa [mul_assoc, Monic.mul_left_eq_zero_iff] at hp
refine monic_mul_C_of_leadingCoeff_mul_eq_one ?_
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Adjoin.FG | {
"line": 54,
"column": 8
} | {
"line": 54,
"column": 18
} | {
"line": 55,
"column": 8
} | [
{
"pp": "R : Type u\nA : Type v\ninst✝² : CommSemiring R\ninst✝¹ : CommSemiring A\ninst✝ : Algebra R A\ns t : Set A\nh1 : (Subalgebra.toSubmodule (adjoin R s)).FG\nh2 : (Subalgebra.toSubmodule (adjoin (↥(adjoin R s)) t)).FG\np : Set A\nhp : p.Finite\nhp' : span R p = Subalgebra.toSubmodule (adjoin R s)\nq : Set... | [
"R : Type u\nA : Type v\ninst✝² : CommSemiring R\ninst✝¹ : CommSemiring A\ninst✝ : Algebra R A\ns t : Set A\nh1 : (Subalgebra.toSubmodule (adjoin R s)).FG\nh2 : (Subalgebra.toSubmodule (adjoin (↥(adjoin R s)) t)).FG\np : Set A\nhp : p.Finite\nhp' : span R p = Subalgebra.toSubmodule (adjoin R s)\nq : Set A\nhq : q.F... | rw [← hp'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 348,
"column": 80
} | {
"line": 348,
"column": 97
} | {
"line": 350,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\ni : ℕ\n⊢ (if i = 0 then 1 else 0) = ↑(if i = 0 then 1 else 0)",
"ppTerm": "?m.32",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Polynomial.instOne",
"Subring.instSetLike",
"Ring.toNonAsso... | [] | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.Ring.GeomSum | {
"line": 242,
"column": 15
} | {
"line": 242,
"column": 25
} | {
"line": 242,
"column": 26
} | [
{
"pp": "R : Type u_1\ninst✝ : Ring R\nx : R\nn : ℕ\nthis : -((∑ i ∈ range n, x ^ i) * (x - 1)) = 1 - x ^ n\n⊢ (∑ i ∈ range n, x ^ i) * (1 - x) = 1 - x ^ n",
"ppTerm": "?m.50",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
... | [
"R : Type u_1\ninst✝ : Ring R\nx : R\nn : ℕ\nthis : (∑ i ∈ range n, x ^ i) * -(x - 1) = 1 - x ^ n\n⊢ (∑ i ∈ range n, x ^ i) * (1 - x) = 1 - x ^ n"
] | ← mul_neg, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Adjoin.Tower | {
"line": 40,
"column": 4
} | {
"line": 42,
"column": 13
} | {
"line": 43,
"column": 2
} | [
{
"pp": "C : Type u_1\nD : Type u_2\nE : Type u_3\ninst✝⁶ : CommSemiring C\ninst✝⁵ : CommSemiring D\ninst✝⁴ : CommSemiring E\ninst✝³ : Algebra C D\ninst✝² : Algebra C E\ninst✝¹ : Algebra D E\ninst✝ : IsScalarTower C D E\nS : Set E\nthis : Set.range ⇑(algebraMap D E) = Set.range ⇑(algebraMap (↥(Subalgebra.map (I... | [] | ext x
change x ∈ Subsemiring.closure (_ ∪ S) ↔ x ∈ Subsemiring.closure (_ ∪ S)
rw [this] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Adjoin.Tower | {
"line": 40,
"column": 4
} | {
"line": 42,
"column": 13
} | {
"line": 43,
"column": 2
} | [
{
"pp": "C : Type u_1\nD : Type u_2\nE : Type u_3\ninst✝⁶ : CommSemiring C\ninst✝⁵ : CommSemiring D\ninst✝⁴ : CommSemiring E\ninst✝³ : Algebra C D\ninst✝² : Algebra C E\ninst✝¹ : Algebra D E\ninst✝ : IsScalarTower C D E\nS : Set E\nthis : Set.range ⇑(algebraMap D E) = Set.range ⇑(algebraMap (↥(Subalgebra.map (I... | [] | ext x
change x ∈ Subsemiring.closure (_ ∪ S) ↔ x ∈ Subsemiring.closure (_ ∪ S)
rw [this] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Algebra.Subalgebra.Operations | {
"line": 69,
"column": 2
} | {
"line": 69,
"column": 61
} | {
"line": 70,
"column": 2
} | [
{
"pp": "R : Type u_1\nS : Type u_2\ninst✝² : CommSemiring R\ninst✝¹ : CommSemiring S\ninst✝ : Algebra R S\nS' : Subalgebra R S\nι : Type u_3\nι' : Finset ι\ns l : ι → S\ne : ∑ i ∈ ι', l i * s i = 1\nhs : ∀ (i : ι), s i ∈ S'\nhl : ∀ (i : ι), l i ∈ S'\nx : S\nn : ι → ℕ\nhn : ∀ (i : ι), s i ^ n i • x ∈ S'\ns' : ι... | [
"R : Type u_1\nS : Type u_2\ninst✝² : CommSemiring R\ninst✝¹ : CommSemiring S\ninst✝ : Algebra R S\nS' : Subalgebra R S\nι : Type u_3\nι' : Finset ι\ns l : ι → S\ne : ∑ i ∈ ι', l i * s i = 1\nhs : ∀ (i : ι), s i ∈ S'\nhl : ∀ (i : ι), l i ∈ S'\nx : S\nn : ι → ℕ\nhn : ∀ (i : ι), s i ^ n i • x ∈ S'\ns' : ι → ↥S' := fu... | refine Submodule.smul_mem _ (⟨_, pow_mem (hs i) _⟩ : S') ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.RingTheory.FiniteType | {
"line": 331,
"column": 79
} | {
"line": 336,
"column": 21
} | {
"line": 338,
"column": 0
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝¹ : CommSemiring R\ninst✝ : AddMonoid M\nf : R[M]\n⊢ f ∈ adjoin R (of' R M '' ↑f.support)",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Submodule",
"AddMonoidAlgebra.semiring",
"Semiring.toModule",
"AddMon... | [] | by
suffices span R (of' R M '' f.support) ≤
Subalgebra.toSubmodule (adjoin R (of' R M '' f.support)) by
exact this (mem_span_support f)
rw [Submodule.span_le]
exact subset_adjoin | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.FiniteType | {
"line": 442,
"column": 2
} | {
"line": 445,
"column": 52
} | {
"line": 447,
"column": 0
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝¹ : AddMonoid M\ninst✝ : CommRing R\nh : AddMonoid.FG M\n⊢ FiniteType R R[M]",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Algebra.FiniteType.of_surjective",
"AddMonoidAlgebra.semiring",
"AddSubmonoid.instTop",
"Equiv.inst... | [] | obtain ⟨S, hS⟩ := h.fg_top
exact .of_surjective
(FreeAlgebra.lift R fun s : (S : Set M) => of' R M ↑s)
(freeAlgebra_lift_of_surjective_of_closure hS) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.FiniteType | {
"line": 442,
"column": 2
} | {
"line": 445,
"column": 52
} | {
"line": 447,
"column": 0
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝¹ : AddMonoid M\ninst✝ : CommRing R\nh : AddMonoid.FG M\n⊢ FiniteType R R[M]",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Algebra.FiniteType.of_surjective",
"AddMonoidAlgebra.semiring",
"AddSubmonoid.instTop",
"Equiv.inst... | [] | obtain ⟨S, hS⟩ := h.fg_top
exact .of_surjective
(FreeAlgebra.lift R fun s : (S : Set M) => of' R M ↑s)
(freeAlgebra_lift_of_surjective_of_closure hS) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.FiniteType | {
"line": 678,
"column": 2
} | {
"line": 687,
"column": 59
} | {
"line": 688,
"column": 2
} | [
{
"pp": "case refine_2\nR : Type u_1\ninst✝ : CommRing R\nM : Type u_1\nx✝² : AddCommMonoid M\nx✝¹ : Module R M\nx✝ : Module.Finite R M\nN : Submodule R M\nf : ↥N →ₗ[R] M\nhf : Surjective ⇑f\nthis✝² : AddCommGroup M := addCommMonoidToAddCommGroup R\nthis✝¹ : AddCommGroup ↥N := addCommMonoidToAddCommGroup R\ni :... | [
"case refine_3\nR : Type u_1\ninst✝ : CommRing R\nM : Type u_1\nx✝³ : AddCommMonoid M\nx✝² : Module R M\nx✝¹ : Module.Finite R M\nN : Submodule R M\nf : ↥N →ₗ[R] M\nhf : Surjective ⇑f\nthis✝² : AddCommGroup M := addCommMonoidToAddCommGroup R\nthis✝¹ : AddCommGroup ↥N := addCommMonoidToAddCommGroup R\ni : ↥N →ₗ[R] M... | · induction hx using span_induction with
| mem x hx =>
change f x ∈ M'
simp only [Set.singleton_union, Set.mem_insert_iff, Set.mem_range] at hx
rcases hx with hx | ⟨j, rfl⟩
· rw [hx, hn]; exact zero_mem _
· exact subset_span (by simp [hnj])
| zero => simp
| add x _ y _ hx hy =>... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Int.ModEq | {
"line": 251,
"column": 2
} | {
"line": 251,
"column": 43
} | {
"line": 253,
"column": 0
} | [
{
"pp": "n a b : ℤ\nh : a ≡ b [ZMOD n]\n⊢ a ≡ 0 [ZMOD n] ↔ b ≡ 0 [ZMOD n]",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Int.ModEq.symm",
"Int.ModEq.trans",
"Int",
"instOfNat",
"Int.ModEq",
"Iff.intro",
"OfNat.ofNat"
],
"usedFVars": [
... | [] | exact ⟨fun ha ↦ h.symm.trans ha, h.trans⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Algebra.Subalgebra.Unitization | {
"line": 142,
"column": 6
} | {
"line": 145,
"column": 24
} | {
"line": 146,
"column": 4
} | [
{
"pp": "case refine_1\nR : Type u_1\nS : Type u_2\nA : Type u_3\ninst✝³ : Field R\ninst✝² : Ring A\ninst✝¹ : Algebra R A\ninst✝ : SetLike S A\nhSA : NonUnitalSubringClass S A\nhSRA : SMulMemClass S R A\ns : S\nh1 : 1 ∉ s\nalgHom : Unitization R ↥s →ₐ[R] ↥(Algebra.adjoin R ↑s) := (unitization s).codRestrict (Al... | [] | have := AlgHomClass.unitization_injective s h1
((Subalgebra.val _).comp algHom) fun _ ↦ by simp [algHom]
rw [AlgHom.coe_comp] at this
exact this.of_comp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Algebra.Subalgebra.Unitization | {
"line": 142,
"column": 6
} | {
"line": 145,
"column": 24
} | {
"line": 146,
"column": 4
} | [
{
"pp": "case refine_1\nR : Type u_1\nS : Type u_2\nA : Type u_3\ninst✝³ : Field R\ninst✝² : Ring A\ninst✝¹ : Algebra R A\ninst✝ : SetLike S A\nhSA : NonUnitalSubringClass S A\nhSRA : SMulMemClass S R A\ns : S\nh1 : 1 ∉ s\nalgHom : Unitization R ↥s →ₐ[R] ↥(Algebra.adjoin R ↑s) := (unitization s).codRestrict (Al... | [] | have := AlgHomClass.unitization_injective s h1
((Subalgebra.val _).comp algHom) fun _ ↦ by simp [algHom]
rw [AlgHom.coe_comp] at this
exact this.of_comp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Permutation | {
"line": 177,
"column": 72
} | {
"line": 177,
"column": 95
} | {
"line": 177,
"column": 95
} | [
{
"pp": "case cons\nα : Type u_1\nt : α\nts : List α\nr : List (List α)\nl : List α\nL : List (List α)\nih :\n foldr (fun y r ↦ (permutationsAux2 t ts r y id).snd) r L =\n flatMap (fun y ↦ (permutationsAux2 t ts [] y id).snd) L ++ r\n⊢ (permutationsAux2 t ts (flatMap (fun y ↦ (permutationsAux2 t ts [] y id)... | [] | permutationsAux2_append | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.List.Permutation | {
"line": 380,
"column": 44
} | {
"line": 380,
"column": 67
} | {
"line": 380,
"column": 67
} | [
{
"pp": "case succ.refine_2.e_b\nα : Type u_1\nn : ℕ\nIH : ∀ (ts : List α), ts.length < n → ts.permutations ~ ts.permutations'\nts✝ : List α\nh✝ : ts✝.length < n + 1\nts : List α\nt : α\nx✝¹ : ts.length < n + 1 → ts.permutations ~ ts.permutations'\nh : ts.length < n\nIH₂ : ts.reverse.permutations ~ ts.permutati... | [
"case succ.refine_2.e_b\nα : Type u_1\nn : ℕ\nIH : ∀ (ts : List α), ts.length < n → ts.permutations ~ ts.permutations'\nts✝ : List α\nh✝ : ts✝.length < n + 1\nts : List α\nt : α\nx✝¹ : ts.length < n + 1 → ts.permutations ~ ts.permutations'\nh : ts.length < n\nIH₂ : ts.reverse.permutations ~ ts.permutations'\nx✝ : L... | permutationsAux2_append | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.GroupAction.Basic | {
"line": 148,
"column": 4
} | {
"line": 148,
"column": 19
} | {
"line": 148,
"column": 19
} | [
{
"pp": "case h\nG : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝² : Group G\ninst✝¹ : MulAction G α\ninst✝ : MulAction G β\na : α\ng h : G\n⊢ ↑((h * g⁻¹) • ⟨(fun m ↦ m • a) g, ⋯⟩) = ↑⟨(fun m ↦ m • a) h, ⋯⟩",
"ppTerm": "?h",
"assigned": true,
"usedConstants": [
"instHSMul",
"HMul.hMul",
... | [] | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.GroupTheory.GroupAction.Basic | {
"line": 209,
"column": 4
} | {
"line": 209,
"column": 19
} | {
"line": 211,
"column": 0
} | [
{
"pp": "case h\nG : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝² : Group G\ninst✝¹ : MulAction G α\ninst✝ : MulAction G β\na✝ : α\ng : G\nyh : (fun m ↦ m • a✝) g ∈ orbitRel.Quotient.orbit (Quotient.mk'' a✝)\nh : G\nzh : (fun m ↦ m • a✝) h ∈ orbitRel.Quotient.orbit (Quotient.mk'' a✝)\n⊢ ↑((h * g⁻¹) • ⟨(fun m ↦ ... | [] | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Cycle | {
"line": 843,
"column": 8
} | {
"line": 843,
"column": 33
} | {
"line": 843,
"column": 34
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\nl m : List α\na : α\n_H : ∀ (hl : m ≠ []), Chain r ↑m ↔ IsChain r (m.getLast hl :: m)\nhl✝ : m ++ [a] ≠ []\n⊢ Chain r ↑(m ++ [a]) ↔ IsChain r ((m ++ [a]).getLast hl✝ :: (m ++ [a]))",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"List.getLast"... | [
"α : Type u_1\nr : α → α → Prop\nl m : List α\na : α\n_H : ∀ (hl : m ≠ []), Chain r ↑m ↔ IsChain r (m.getLast hl :: m)\nhl✝ : m ++ [a] ≠ []\n⊢ Chain r ↑(a :: m) ↔ IsChain r ((m ++ [a]).getLast hl✝ :: (m ++ [a]))"
] | ← coe_cons_eq_coe_append, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Cycle | {
"line": 854,
"column": 18
} | {
"line": 854,
"column": 43
} | {
"line": 854,
"column": 44
} | [
{
"pp": "r : ℕ → ℕ → Prop\nn : ℕ\n⊢ Chain r ↑(range n ++ [n]) ↔ r n 0 ∧ ∀ m < n, r m m.succ",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Cycle.coe_cons_eq_coe_append",
"id",
"instOfNatNat",
"List.range",
"Cycle.Chain",
... | [
"r : ℕ → ℕ → Prop\nn : ℕ\n⊢ Chain r ↑(n :: range n) ↔ r n 0 ∧ ∀ m < n, r m m.succ"
] | ← coe_cons_eq_coe_append, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.GroupAction.Quotient | {
"line": 296,
"column": 34
} | {
"line": 296,
"column": 49
} | {
"line": 296,
"column": 49
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\ninst✝³ : Group α\ninst✝² : MulAction α β\nx : β\ninst✝¹ : IsPretransitive α β\nH : Subgroup α\ninst✝ : Finite (α ⧸ H)\nb : β\nh' : Finite (Quotient (rightRel H))\na : Quotient (rightRel H)\ng₁ g₂ : α\nr : g₁ * g₂⁻¹ ∈ H\n⊢ ⟨g₁ * g₂⁻¹, r⟩ • g₂ • b = g₁ • b",
"ppTer... | [] | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.GroupTheory.GroupAction.Quotient | {
"line": 296,
"column": 34
} | {
"line": 296,
"column": 49
} | {
"line": 296,
"column": 49
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\ninst✝³ : Group α\ninst✝² : MulAction α β\nx : β\ninst✝¹ : IsPretransitive α β\nH : Subgroup α\ninst✝ : Finite (α ⧸ H)\nb : β\nh' : Finite (Quotient (rightRel H))\na : Quotient (rightRel H)\ng₁ g₂ : α\nr : g₁ * g₂⁻¹ ∈ H\n⊢ ⟨g₁ * g₂⁻¹, r⟩ • g₂ • b = g₁ • b",
"ppTer... | [] | simp [mul_smul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.GroupAction.Quotient | {
"line": 296,
"column": 34
} | {
"line": 296,
"column": 49
} | {
"line": 296,
"column": 49
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\ninst✝³ : Group α\ninst✝² : MulAction α β\nx : β\ninst✝¹ : IsPretransitive α β\nH : Subgroup α\ninst✝ : Finite (α ⧸ H)\nb : β\nh' : Finite (Quotient (rightRel H))\na : Quotient (rightRel H)\ng₁ g₂ : α\nr : g₁ * g₂⁻¹ ∈ H\n⊢ ⟨g₁ * g₂⁻¹, r⟩ • g₂ • b = g₁ • b",
"ppTer... | [] | simp [mul_smul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.GroupAction.Quotient | {
"line": 374,
"column": 22
} | {
"line": 374,
"column": 37
} | {
"line": 374,
"column": 37
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\ninst✝³ : Group α\ninst✝² : MulAction α β\nx : β\ninst✝¹ : IsPretransitive α β\ninst✝ : IsCancelSMul α β\nH : Subgroup α\nq : α ⧸ H\ng₁ g₂ : α\nh : g₁⁻¹ * g₂ ∈ H\n⊢ (fun m ↦ m • g₂⁻¹ • x) ⟨g₁⁻¹ * g₂, h⟩ = g₁⁻¹ • x",
"ppTerm": "?m.197",
"assigned": true,
"u... | [] | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.GroupTheory.GroupAction.Quotient | {
"line": 374,
"column": 22
} | {
"line": 374,
"column": 37
} | {
"line": 374,
"column": 37
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\ninst✝³ : Group α\ninst✝² : MulAction α β\nx : β\ninst✝¹ : IsPretransitive α β\ninst✝ : IsCancelSMul α β\nH : Subgroup α\nq : α ⧸ H\ng₁ g₂ : α\nh : g₁⁻¹ * g₂ ∈ H\n⊢ (fun m ↦ m • g₂⁻¹ • x) ⟨g₁⁻¹ * g₂, h⟩ = g₁⁻¹ • x",
"ppTerm": "?m.197",
"assigned": true,
"u... | [] | simp [mul_smul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.GroupAction.Quotient | {
"line": 374,
"column": 22
} | {
"line": 374,
"column": 37
} | {
"line": 374,
"column": 37
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\ninst✝³ : Group α\ninst✝² : MulAction α β\nx : β\ninst✝¹ : IsPretransitive α β\ninst✝ : IsCancelSMul α β\nH : Subgroup α\nq : α ⧸ H\ng₁ g₂ : α\nh : g₁⁻¹ * g₂ ∈ H\n⊢ (fun m ↦ m • g₂⁻¹ • x) ⟨g₁⁻¹ * g₂, h⟩ = g₁⁻¹ • x",
"ppTerm": "?m.197",
"assigned": true,
"u... | [] | simp [mul_smul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Factors | {
"line": 174,
"column": 8
} | {
"line": 174,
"column": 24
} | {
"line": 174,
"column": 24
} | [
{
"pp": "case refine_1\nl : List ℕ\nh₂ : ∀ (p : ℕ), p ∈ l → Prime p\nh₁ : l.prod = 0\n⊢ False",
"ppTerm": "?refine_1",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"IsDomain.to_noZeroDivisors",
"MulZeroClass.toMul",
"Nat.instNontrivial",
"congrArg",
"Membe... | [
"case refine_1\nl : List ℕ\nh₂ : ∀ (p : ℕ), p ∈ l → Prime p\nh₁ : 0 ∈ l\n⊢ False"
] | prod_eq_zero_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Index | {
"line": 310,
"column": 59
} | {
"line": 311,
"column": 73
} | {
"line": 313,
"column": 0
} | [
{
"pp": "G : Type u_1\nG' : Type u_2\ninst✝¹ : Group G\ninst✝ : Group G'\nH : Subgroup G\nf : G →* G'\n⊢ (map f H).index = (H ⊔ f.ker).index * f.range.index",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MonoidHom.range",
"Lattice.toSemilatticeSup",
"Sub... | [] | by
rw [← comap_map_eq, index_comap, relIndex_mul_index (H.map_le_range f)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Index | {
"line": 421,
"column": 2
} | {
"line": 421,
"column": 36
} | {
"line": 423,
"column": 0
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nJ K : Subgroup G\nhJK : J.relIndex K ≠ 0\nL : Subgroup G\n⊢ (comap L.subtype J).relIndex (comap L.subtype K) ≠ 0",
"ppTerm": "?m.67",
"assigned": true,
"usedConstants": [
"Subgroup.subtype",
"Membership.mem",
"Subtype",
"Subgroup",
... | [] | exact relIndex_comap_ne_zero _ hJK | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.GroupTheory.Index | {
"line": 492,
"column": 4
} | {
"line": 492,
"column": 24
} | {
"line": 493,
"column": 4
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nha : ∀ (b : G), b * a ∈ H ∨ b ∈ H\n⊢ H.index ∣ 2",
"ppTerm": "?m.136",
"assigned": true,
"usedConstants": [
"Dvd.dvd",
"Classical.propDecidable",
"Membership.mem",
"Subgroup",
"instOfNatNat",
"dite",
... | [
"case pos\nG : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nha : ∀ (b : G), b * a ∈ H ∨ b ∈ H\nha' : a ∈ H\n⊢ H.index ∣ 2",
"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\n⊢ H.index ∣ 2"
] | by_cases ha' : a ∈ H | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Data.ZMod.Basic | {
"line": 156,
"column": 2
} | {
"line": 156,
"column": 30
} | {
"line": 157,
"column": 2
} | [
{
"pp": "p n q : ℕ\nh : n ≤ n + q\n⊢ ↑p ^ (n + q) = 0",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"ZMod.commRing",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
... | [
"p n q : ℕ\nh : n ≤ n + q\n⊢ ↑(p ^ n) * ↑p ^ q = 0"
] | rw [pow_add, ← Nat.cast_pow] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Ring.GeomSum | {
"line": 67,
"column": 4
} | {
"line": 67,
"column": 21
} | {
"line": 68,
"column": 4
} | [
{
"pp": "case refine_1\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : PartialOrder R\ninst✝ : IsStrictOrderedRing R\nn : ℕ\nx : R\nhx : x < 0\nhx' : 0 < x + 1\nhn : 1 < n\n⊢ 0 < ∑ i ∈ range 2, x ^ i ∧ ∑ i ∈ range 2, x ^ i < 1",
"ppTerm": "?refine_1",
"assigned": true,
"usedConstants": [
"Eq.mpr",
... | [
"case refine_1\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : PartialOrder R\ninst✝ : IsStrictOrderedRing R\nn : ℕ\nx : R\nhx : x < 0\nhx' : 0 < x + 1\nhn : 1 < n\n⊢ 0 < x + 1 ∧ x + 1 < 1"
] | rw [geom_sum_two] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.ZMod.Basic | {
"line": 553,
"column": 36
} | {
"line": 553,
"column": 50
} | {
"line": 553,
"column": 51
} | [
{
"pp": "case succ\nR : Type u_1\ninst✝ : Ring R\nn : ℕ\n⊢ ↑n = ↑(n + 1) - 1",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"AddMonoid.toAddSemigroup",
"AddGroupWithOne.toAddGroup",
"congrArg",
"AddGroupWithOne.toAddMonoidWith... | [
"case succ\nR : Type u_1\ninst✝ : Ring R\nn : ℕ\n⊢ ↑n = ↑n + 1 - 1"
] | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.Divisors | {
"line": 418,
"column": 20
} | {
"line": 418,
"column": 33
} | {
"line": 418,
"column": 34
} | [
{
"pp": "p : ℕ\npp : Prime p\na✝ : ℕ\n⊢ a✝ ∣ p ∧ p ≠ 0 ↔ a✝ ∈ {1, p}",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"congrArg",
"Finset",
"Membership.mem",
"id",
"Insert.insert",
"Ne",
"instOfNatNat",
"Nat.dv... | [
"p : ℕ\npp : Prime p\na✝ : ℕ\n⊢ (a✝ = 1 ∨ a✝ = p) ∧ p ≠ 0 ↔ a✝ ∈ {1, p}"
] | dvd_prime pp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.ZMod.Basic | {
"line": 960,
"column": 25
} | {
"line": 960,
"column": 63
} | {
"line": 962,
"column": 0
} | [
{
"pp": "case inl\na : ℤ\nh✝ : a ≤ 0\n⊢ ↑|a| = ↑a",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast_neg",
"Int.cast",
"NegZeroClass.toNeg",
"ZMod.commRing",
"AddGroupWithOne.toAddGroup",
"abs",
"congrArg... | [] | simp [abs_of_nonneg, abs_of_nonpos, *] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.ZMod.Basic | {
"line": 960,
"column": 25
} | {
"line": 960,
"column": 63
} | {
"line": 962,
"column": 0
} | [
{
"pp": "case inr\na : ℤ\nh✝ : 0 ≤ a\n⊢ ↑|a| = ↑a",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"Int.cast",
"ZMod.commRing",
"abs",
"congrArg",
"instOfNatNat",
"Int",
"AddGroupWithOne.toIntCast",
"ZMod",
"Nat",
"True",
"eq_... | [] | simp [abs_of_nonneg, abs_of_nonpos, *] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.ZMod.Basic | {
"line": 987,
"column": 10
} | {
"line": 987,
"column": 19
} | {
"line": 987,
"column": 20
} | [
{
"pp": "case succ.mp.zero\nn✝ : ℕ\na : ZMod (n✝ + 1)\nhe : 2 * a.val = (n✝ + 1) * 0\n⊢ a = 0 ∨ 2 * a.val = n✝ + 1",
"ppTerm": "?succ.mp.zero",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"Eq.mp",
"in... | [
"case succ.mp.zero\nn✝ : ℕ\na : ZMod (n✝ + 1)\nhe : 2 * a.val = 0\n⊢ a = 0 ∨ 2 * a.val = n✝ + 1"
] | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Digits.Defs | {
"line": 169,
"column": 77
} | {
"line": 174,
"column": 8
} | {
"line": 176,
"column": 0
} | [
{
"pp": "b : ℕ\nl1 l2 : List ℕ\n⊢ ofDigits b (l1 ++ l2) = ofDigits b l1 + b ^ l1.length * ofDigits b l2",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Nat.pow_succ'",
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"instPowNat",
"Eq.mpr",
"NonAssocSemiring.toAddCo... | [] | by
induction l1 with
| nil => simp [ofDigits]
| cons hd tl IH =>
rw [ofDigits, List.cons_append, ofDigits, IH, List.length_cons, pow_succ']
ring | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Digits.Defs | {
"line": 179,
"column": 43
} | {
"line": 179,
"column": 52
} | {
"line": 179,
"column": 53
} | [
{
"pp": "b : ℕ\nl : List ℕ\n⊢ ofDigits b l + b ^ l.length * 0 = ofDigits b l",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instMulZeroClass",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"Nat.instMonoid",
"Nat.ofDigits",
"i... | [
"b : ℕ\nl : List ℕ\n⊢ ofDigits b l + 0 = ofDigits b l"
] | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.ZMod.Basic | {
"line": 1083,
"column": 8
} | {
"line": 1083,
"column": 17
} | {
"line": 1083,
"column": 18
} | [
{
"pp": "case inl\nn : ℕ\nx : ℤ\nhl : x.natAbs ≤ n / 2\n⊢ x.natAbs ≤ (↑n * 0 + x).natAbs",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"... | [
"case inl\nn : ℕ\nx : ℤ\nhl : x.natAbs ≤ n / 2\n⊢ x.natAbs ≤ (0 + x).natAbs"
] | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 167,
"column": 2
} | {
"line": 179,
"column": 47
} | {
"line": 181,
"column": 0
} | [
{
"pp": "p n k l : ℕ\nhn : n ≠ 0\nh : p ^ k * l = n\nhl : ¬p ∣ l\n⊢ p.maxPowDvdDiv n = (k, l)",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"_private.Mathlib.Data.Nat.MaxPowDiv.0.Nat.pow_dvd_iff_le_of_spec",
"instPowNat",
"Eq.mpr",
"False",
"Nat.mul_left_can... | [] | obtain rfl | rfl | hp : p = 0 ∨ p = 1 ∨ 1 < p := by grind
· cases k.eq_zero_or_pos <;> simp_all
· simp_all
· have hk : k = (p.maxPowDvdDiv n).1 := by
· apply Nat.le_antisymm
· rw [← padicValNat, ← pow_dvd_iff_le_padicValNat (Nat.ne_of_gt hp) hn,
pow_dvd_iff_le_of_spec hp hn h hl]
... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 167,
"column": 2
} | {
"line": 179,
"column": 47
} | {
"line": 181,
"column": 0
} | [
{
"pp": "p n k l : ℕ\nhn : n ≠ 0\nh : p ^ k * l = n\nhl : ¬p ∣ l\n⊢ p.maxPowDvdDiv n = (k, l)",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"_private.Mathlib.Data.Nat.MaxPowDiv.0.Nat.pow_dvd_iff_le_of_spec",
"instPowNat",
"Eq.mpr",
"False",
"Nat.mul_left_can... | [] | obtain rfl | rfl | hp : p = 0 ∨ p = 1 ∨ 1 < p := by grind
· cases k.eq_zero_or_pos <;> simp_all
· simp_all
· have hk : k = (p.maxPowDvdDiv n).1 := by
· apply Nat.le_antisymm
· rw [← padicValNat, ← pow_dvd_iff_le_padicValNat (Nat.ne_of_gt hp) hn,
pow_dvd_iff_le_of_spec hp hn h hl]
... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Digits.Defs | {
"line": 390,
"column": 90
} | {
"line": 391,
"column": 69
} | {
"line": 393,
"column": 0
} | [
{
"pp": "b m : ℕ\nhb : 1 < b\n⊢ m < b ^ (b.digits m).length",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"not_lt_zero._simp_1",
"False",
"Nat.instMulZeroClass",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"congrArg",
"Nat.instMonoid",
"F... | [] | by
rcases b with (_ | _ | b) <;> simp_all [lt_base_pow_length_digits'] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 188,
"column": 31
} | {
"line": 188,
"column": 39
} | {
"line": 188,
"column": 40
} | [
{
"pp": "case inl.cons.inr\np : ℕ\nh : 1 < p\nhd : ℕ\ntl : List ℕ\nih✝ :\n ∀ {h_nonempty : tl ≠ []},\n tl.getLast h_nonempty ≠ 0 →\n (∀ l ∈ tl, l < p) → (p - 1) * ∑ i ∈ range tl.length, ofDigits p tl / p ^ i.succ = ofDigits p tl - tl.sum\nh_nonempty : hd :: tl ≠ []\nh_ne_zero : (hd :: tl).getLast h_non... | [
"case inl.cons.inr\np : ℕ\nh : 1 < p\nhd : ℕ\ntl : List ℕ\nih✝ :\n ∀ {h_nonempty : tl ≠ []},\n tl.getLast h_nonempty ≠ 0 →\n (∀ l ∈ tl, l < p) → (p - 1) * ∑ i ∈ range tl.length, ofDigits p tl / p ^ i.succ = ofDigits p tl - tl.sum\nh_nonempty : hd :: tl ≠ []\nh_ne_zero : (hd :: tl).getLast h_nonempty ≠ 0\nh... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 108,
"column": 5
} | {
"line": 108,
"column": 75
} | {
"line": 108,
"column": 75
} | [
{
"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... | [] | by simpa only [List.perm_iff_count, primeFactorsList_count_eq] using h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 188,
"column": 40
} | {
"line": 188,
"column": 48
} | {
"line": 188,
"column": 49
} | [
{
"pp": "case inl.cons.inr\np : ℕ\nh : 1 < p\nhd : ℕ\ntl : List ℕ\nih✝ :\n ∀ {h_nonempty : tl ≠ []},\n tl.getLast h_nonempty ≠ 0 →\n (∀ l ∈ tl, l < p) → (p - 1) * ∑ i ∈ range tl.length, ofDigits p tl / p ^ i.succ = ofDigits p tl - tl.sum\nh_nonempty : hd :: tl ≠ []\nh_ne_zero : (hd :: tl).getLast h_non... | [
"case inl.cons.inr\np : ℕ\nh : 1 < p\nhd : ℕ\ntl : List ℕ\nih✝ :\n ∀ {h_nonempty : tl ≠ []},\n tl.getLast h_nonempty ≠ 0 →\n (∀ l ∈ tl, l < p) → (p - 1) * ∑ i ∈ range tl.length, ofDigits p tl / p ^ i.succ = ofDigits p tl - tl.sum\nh_nonempty : hd :: tl ≠ []\nh_ne_zero : (hd :: tl).getLast h_nonempty ≠ 0\nh... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 189,
"column": 12
} | {
"line": 189,
"column": 21
} | {
"line": 189,
"column": 22
} | [
{
"pp": "case inl.cons.inr\np : ℕ\nh : 1 < p\nhd : ℕ\ntl : List ℕ\nih✝ :\n ∀ {h_nonempty : tl ≠ []},\n tl.getLast h_nonempty ≠ 0 →\n (∀ l ∈ tl, l < p) → (p - 1) * ∑ i ∈ range tl.length, ofDigits p tl / p ^ i.succ = ofDigits p tl - tl.sum\nh_nonempty : hd :: tl ≠ []\nh_ne_zero : (hd :: tl).getLast h_non... | [
"case inl.cons.inr\np : ℕ\nh : 1 < p\nhd : ℕ\ntl : List ℕ\nih✝ :\n ∀ {h_nonempty : tl ≠ []},\n tl.getLast h_nonempty ≠ 0 →\n (∀ l ∈ tl, l < p) → (p - 1) * ∑ i ∈ range tl.length, ofDigits p tl / p ^ i.succ = ofDigits p tl - tl.sum\nh_nonempty : hd :: tl ≠ []\nh_ne_zero : (hd :: tl).getLast h_nonempty ≠ 0\nh... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Multiplicity | {
"line": 96,
"column": 4
} | {
"line": 97,
"column": 60
} | {
"line": 99,
"column": 0
} | [
{
"pp": "case mpr\nα : Type u_1\ninst✝ : Monoid α\na b : α\nn : ℕ\nh : n ≠ 1\n⊢ multiplicity a b = n → emultiplicity a b = ↑n",
"ppTerm": "?mpr",
"assigned": true,
"usedConstants": [
"False",
"eq_false",
"congrArg",
"_private.Mathlib.RingTheory.Multiplicity.0.emultiplicity_eq... | [] | intro h₂
simpa [multiplicity, WithTop.untopD_eq_iff, h] using! h₂ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Multiplicity | {
"line": 96,
"column": 4
} | {
"line": 97,
"column": 60
} | {
"line": 99,
"column": 0
} | [
{
"pp": "case mpr\nα : Type u_1\ninst✝ : Monoid α\na b : α\nn : ℕ\nh : n ≠ 1\n⊢ multiplicity a b = n → emultiplicity a b = ↑n",
"ppTerm": "?mpr",
"assigned": true,
"usedConstants": [
"False",
"eq_false",
"congrArg",
"_private.Mathlib.RingTheory.Multiplicity.0.emultiplicity_eq... | [] | intro h₂
simpa [multiplicity, WithTop.untopD_eq_iff, h] using! h₂ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 282,
"column": 6
} | {
"line": 282,
"column": 24
} | {
"line": 282,
"column": 25
} | [
{
"pp": "a b : ℕ\nhab : a.Coprime b\nq : ℕ\n⊢ (a * b).factorization q = (a.factorization + b.factorization) q",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instMulZeroClass",
"HMul.hMul",
"congrArg",
"AddMonoid.toA... | [
"a b : ℕ\nhab : a.Coprime b\nq : ℕ\n⊢ (a * b).factorization q = a.factorization q + b.factorization q"
] | Finsupp.add_apply, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 306,
"column": 2
} | {
"line": 308,
"column": 63
} | {
"line": 310,
"column": 0
} | [
{
"pp": "a b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\n⊢ (∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p) ↔ a ∣ b",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"Finsupp.instFunLike",
"Eq.mpr",
"Finsupp.instLE",
... | [] | rw [← factorization_le_iff_dvd ha hb, Finsupp.le_def]
congr! 1 with p
obtain _ | _ | p := p <;> simp [Nat.pow_dvd_pow_iff_le_right] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 306,
"column": 2
} | {
"line": 308,
"column": 63
} | {
"line": 310,
"column": 0
} | [
{
"pp": "a b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\n⊢ (∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p) ↔ a ∣ b",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"Finsupp.instFunLike",
"Eq.mpr",
"Finsupp.instLE",
... | [] | rw [← factorization_le_iff_dvd ha hb, Finsupp.le_def]
congr! 1 with p
obtain _ | _ | p := p <;> simp [Nat.pow_dvd_pow_iff_le_right] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Multiplicity | {
"line": 216,
"column": 4
} | {
"line": 218,
"column": 44
} | {
"line": 219,
"column": 2
} | [
{
"pp": "case isTrue\nα : Type u_1\ninst✝ : Monoid α\na b : α\nm : ℕ\nnh : a ^ m ∣ b\nh✝ : FiniteMultiplicity a b\nhm : ↑(Nat.find h✝) < ↑m\n⊢ False",
"ppTerm": "?isTrue",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"False",
"Preorder.toLT",
"Dvd.dvd",
"ins... | [] | simp only [cast_lt, find_lt_iff] at hm
obtain ⟨n, hn1, hn2⟩ := hm
exact hn2 ((pow_dvd_pow _ hn1).trans nh) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Multiplicity | {
"line": 216,
"column": 4
} | {
"line": 218,
"column": 44
} | {
"line": 219,
"column": 2
} | [
{
"pp": "case isTrue\nα : Type u_1\ninst✝ : Monoid α\na b : α\nm : ℕ\nnh : a ^ m ∣ b\nh✝ : FiniteMultiplicity a b\nhm : ↑(Nat.find h✝) < ↑m\n⊢ False",
"ppTerm": "?isTrue",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"False",
"Preorder.toLT",
"Dvd.dvd",
"ins... | [] | simp only [cast_lt, find_lt_iff] at hm
obtain ⟨n, hn1, hn2⟩ := hm
exact hn2 ((pow_dvd_pow _ hn1).trans nh) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.OrderOfElement | {
"line": 275,
"column": 19
} | {
"line": 275,
"column": 37
} | {
"line": 275,
"column": 38
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx : G\nn : ℕ\nh : orderOf x ∣ n\n⊢ x ^ n = 1",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Monoid.toMulOneClass",
"congrArg",
"pow_mod_orderOf",
"id",
"Nat.instMod",
"instH... | [
"G : Type u_1\ninst✝ : Monoid G\nx : G\nn : ℕ\nh : orderOf x ∣ n\n⊢ x ^ (n % orderOf x) = 1"
] | ← pow_mod_orderOf, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.OrderOfElement | {
"line": 325,
"column": 30
} | {
"line": 325,
"column": 48
} | {
"line": 325,
"column": 49
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx : G\nn : ℕ\nh✝ : n.Coprime (orderOf x)\nh0 : ¬orderOf x = 0\nh1 : ¬orderOf x = 1\nm : ℕ\nh : n * m % orderOf x = 1\n⊢ x ^ (n * m) = x",
"ppTerm": "?m.120",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"pow_... | [
"G : Type u_1\ninst✝ : Monoid G\nx : G\nn : ℕ\nh✝ : n.Coprime (orderOf x)\nh0 : ¬orderOf x = 0\nh1 : ¬orderOf x = 1\nm : ℕ\nh : n * m % orderOf x = 1\n⊢ x ^ (n * m % orderOf x) = x"
] | ← pow_mod_orderOf, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Multiplicity | {
"line": 586,
"column": 2
} | {
"line": 586,
"column": 54
} | {
"line": 586,
"column": 55
} | [
{
"pp": "α : Type u_1\ninst✝ : Ring α\np a b : α\nh : multiplicity p b < multiplicity p a\nhfin : FiniteMultiplicity p b\n⊢ multiplicity p (a - b) = multiplicity p b",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NegZeroClass.toNeg",
"AddGroupWithOne.toAddGrou... | [
"α : Type u_1\ninst✝ : Ring α\np a b : α\nh : multiplicity p b < multiplicity p a\nhfin : FiniteMultiplicity p b\n⊢ multiplicity p (-b) = multiplicity p b",
"α : Type u_1\ninst✝ : Ring α\np a b : α\nh : multiplicity p b < multiplicity p a\nhfin : FiniteMultiplicity p b\n⊢ multiplicity p (-b) < multiplicity p a"
] | rw [sub_eq_add_neg, hfin.neg.multiplicity_add_of_gt] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.OrderOfElement | {
"line": 573,
"column": 67
} | {
"line": 573,
"column": 85
} | {
"line": 573,
"column": 86
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx : G\nhx : IsOfFinOrder x\nn : ℕ\n⊢ x ^ n = x ^ ↑⟨n % orderOf x, ⋯⟩",
"ppTerm": "?m.54",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"IsOfFinOrder.orderOf_pos",
"congrArg",
"pow_mod_orderOf",
"Fin.mk",
"id",
"Nat.... | [
"G : Type u_1\ninst✝ : Monoid G\nx : G\nhx : IsOfFinOrder x\nn : ℕ\n⊢ x ^ (n % orderOf x) = x ^ ↑⟨n % orderOf x, ⋯⟩"
] | ← pow_mod_orderOf, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Multiplicity | {
"line": 179,
"column": 50
} | {
"line": 181,
"column": 33
} | {
"line": 183,
"column": 0
} | [
{
"pp": "p n r b : ℕ\nhp : Prime p\nhbn : log p n < b\n⊢ p ^ r ∣ n ! ↔ r ≤ ∑ i ∈ Ico 1 b, n / p ^ i",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"ENat.some_eq_coe",
"Dvd.dvd",
"instHDiv",
"ENat.instNatCast",
"Nat.Prime.emultiplicity_factoria... | [] | by
rw [← WithTop.coe_le_coe, ENat.some_eq_coe, ← hp.emultiplicity_factorial hbn,
pow_dvd_iff_le_emultiplicity] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Choose.Factorization | {
"line": 190,
"column": 4
} | {
"line": 190,
"column": 39
} | {
"line": 191,
"column": 4
} | [
{
"pp": "p n k : ℕ\nh : ¬(n.choose k).factorization p = 0\nhp : Prime p\n⊢ k ≤ n",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"PartialOrder.toPreorder",
"le_of_not_gt",
"Nat",
"LT.lt",
"LinearOrder.toPartialOrder",
"Nat.instLine... | [
"p n k : ℕ\nh : ¬(n.choose k).factorization p = 0\nhp : Prime p\nhnk : n < k\n⊢ (n.choose k).factorization p = 0"
] | refine le_of_not_gt fun hnk => h ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.GroupTheory.OrderOfElement | {
"line": 1065,
"column": 2
} | {
"line": 1065,
"column": 36
} | {
"line": 1066,
"column": 2
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nx : G\nhx : ¬IsOfFinOrder x\nk : ℤ\nh : zpowers x = zpowers (x ^ k)\nhx_mem : x ∈ zpowers (x ^ k)\nhy_mem : x ^ k ∈ zpowers x\nl : ℤ\nhl : x ^ (k * l) = x\n⊢ x = x ^ k ∨ x⁻¹ = x ^ k",
"ppTerm": "?m.108",
"assigned": true,
"usedConstants": [
"HMul.hMul",
... | [
"G : Type u_1\ninst✝ : Group G\nx : G\nhx : ¬IsOfFinOrder x\nk : ℤ\nh : zpowers x = zpowers (x ^ k)\nhx_mem : x ∈ zpowers (x ^ k)\nhy_mem : x ^ k ∈ zpowers x\nl : ℤ\nhl : x ^ (k * l) = x ^ 1\n⊢ x = x ^ k ∨ x⁻¹ = x ^ k"
] | nth_rewrite 2 [← zpow_one x] at hl | Mathlib.Tactic._aux_Mathlib_Tactic_NthRewrite___macroRules_Mathlib_Tactic_tacticNth_rewrite______1 | Mathlib.Tactic.tacticNth_rewrite_____ |
Mathlib.GroupTheory.OrderOfElement | {
"line": 1197,
"column": 15
} | {
"line": 1197,
"column": 33
} | {
"line": 1197,
"column": 34
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Group G\ninst✝ : Fintype G\na : G\nn : ℕ\n⊢ a ^ n = a ^ (n % card G)",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"pow_mod_orderOf",
"Fintype.card",
"id",
"Nat.instMod",
"instHMod",
"Di... | [
"G : Type u_1\ninst✝¹ : Group G\ninst✝ : Fintype G\na : G\nn : ℕ\n⊢ a ^ (n % orderOf a) = a ^ (n % card G)"
] | ← pow_mod_orderOf, | Lean.Elab.Tactic.evalRewriteSeq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.