module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.Algebra.MvPolynomial.Eval | {
"line": 78,
"column": 2
} | {
"line": 78,
"column": 42
} | [
{
"pp": "R : Type u\nS₁ : Type v\nσ : Type u_1\ninst✝² : CommSemiring R\ninst✝¹ : CommSemiring S₁\ninst✝ : Fintype σ\ng : R →+* S₁\nX : σ → S₁\nf : MvPolynomial σ R\n⊢ eval₂ g X f = ∑ d ∈ f.support, g (coeff d f) * ∏ i, X i ^ d i",
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.i... | simp only [eval₂_eq, ← Finsupp.prod_pow] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.MvPolynomial.Eval | {
"line": 77,
"column": 69
} | {
"line": 79,
"column": 5
} | [
{
"pp": "R : Type u\nS₁ : Type v\nσ : Type u_1\ninst✝² : CommSemiring R\ninst✝¹ : CommSemiring S₁\ninst✝ : Fintype σ\ng : R →+* S₁\nX : σ → S₁\nf : MvPolynomial σ R\n⊢ eval₂ g X f = ∑ d ∈ f.support, g (coeff d f) * ∏ i, X i ^ d i",
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.i... | by
simp only [eval₂_eq, ← Finsupp.prod_pow]
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.MvPolynomial.Basic | {
"line": 690,
"column": 47
} | {
"line": 693,
"column": 19
} | [
{
"pp": "R : Type u\nσ : Type u_1\ninst✝¹ : CommSemiring R\ninst✝ : DecidableEq σ\np q : MvPolynomial σ R\n⊢ p.support \\ q.support ⊆ (p + q).support",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"False",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"e... | by
intro m hm
simp only [Classical.not_not, mem_support_iff, Finset.mem_sdiff, Ne] at hm
simp [hm.2, hm.1] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finsupp.Lex | {
"line": 136,
"column": 79
} | {
"line": 144,
"column": 16
} | [
{
"pp": "α : Type u_1\ninst✝ : LinearOrder α\n⊢ StrictAnti fun a ↦ toLex (single a 1)",
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"False",
"Nat.instMulZeroClass",
"Preorder.toLT",
"Finsupp.single_eq_same",
"Equiv.instEquivLike",
"eq_false",
"Na... | by
intro a b h
simp only [LT.lt, Finsupp.lex_def]
simp only [ofLex_toLex, Nat.lt_eq]
use a
constructor
· intro d hd
simp only [Finsupp.single_eq_of_ne hd.ne, Finsupp.single_eq_of_ne (hd.trans h).ne]
· simp [h.ne'] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.MvPolynomial.Variables | {
"line": 113,
"column": 2
} | {
"line": 113,
"column": 37
} | [
{
"pp": "R : Type u\nσ : Type u_1\ninst✝ : CommSemiring R\np : MvPolynomial σ R\nh : p.vars = ∅\n⊢ p = C (coeff 0 p)",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Eq.mpr",
"Nat.instMulZeroClass",
"congrArg",
"CommSemiring.toSemiring",
"AddMonoid.toAddZeroClass",
... | rw [← totalDegree_eq_zero_iff_eq_C] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.MvPolynomial.Rename | {
"line": 256,
"column": 2
} | {
"line": 258,
"column": 14
} | [
{
"pp": "σ : Type u_1\nτ : Type u_2\nR : Type u_4\nS : Type u_5\ninst✝¹ : CommSemiring R\ninst✝ : CommSemiring S\nf : R →+* S\nk : σ → τ\ng : τ → S\np : MvPolynomial σ R\n⊢ eval₂ f g ((rename k) p) = eval₂ f (g ∘ k) p",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
... | apply MvPolynomial.induction_on p <;>
· intros
simp [*] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.MvPolynomial.Rename | {
"line": 256,
"column": 2
} | {
"line": 258,
"column": 14
} | [
{
"pp": "σ : Type u_1\nτ : Type u_2\nR : Type u_4\nS : Type u_5\ninst✝¹ : CommSemiring R\ninst✝ : CommSemiring S\nf : R →+* S\nk : σ → τ\ng : τ → S\np : MvPolynomial σ R\n⊢ eval₂ f g ((rename k) p) = eval₂ f (g ∘ k) p",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
... | apply MvPolynomial.induction_on p <;>
· intros
simp [*] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MvPolynomial.Rename | {
"line": 256,
"column": 2
} | {
"line": 258,
"column": 14
} | [
{
"pp": "σ : Type u_1\nτ : Type u_2\nR : Type u_4\nS : Type u_5\ninst✝¹ : CommSemiring R\ninst✝ : CommSemiring S\nf : R →+* S\nk : σ → τ\ng : τ → S\np : MvPolynomial σ R\n⊢ eval₂ f g ((rename k) p) = eval₂ f (g ∘ k) p",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
... | apply MvPolynomial.induction_on p <;>
· intros
simp [*] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.MvPolynomial.Rename | {
"line": 275,
"column": 2
} | {
"line": 277,
"column": 14
} | [
{
"pp": "σ : Type u_1\nτ : Type u_2\nR : Type u_4\ninst✝ : CommSemiring R\nk : σ → τ\np : MvPolynomial σ R\ng : τ → MvPolynomial σ R\n⊢ (rename k) (eval₂ C (g ∘ k) p) = eval₂ C (⇑(rename k) ∘ g) ((rename k) p)",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
"AddMon... | apply MvPolynomial.induction_on p <;>
· intros
simp [*] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.MvPolynomial.Rename | {
"line": 275,
"column": 2
} | {
"line": 277,
"column": 14
} | [
{
"pp": "σ : Type u_1\nτ : Type u_2\nR : Type u_4\ninst✝ : CommSemiring R\nk : σ → τ\np : MvPolynomial σ R\ng : τ → MvPolynomial σ R\n⊢ (rename k) (eval₂ C (g ∘ k) p) = eval₂ C (⇑(rename k) ∘ g) ((rename k) p)",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
"AddMon... | apply MvPolynomial.induction_on p <;>
· intros
simp [*] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MvPolynomial.Rename | {
"line": 275,
"column": 2
} | {
"line": 277,
"column": 14
} | [
{
"pp": "σ : Type u_1\nτ : Type u_2\nR : Type u_4\ninst✝ : CommSemiring R\nk : σ → τ\np : MvPolynomial σ R\ng : τ → MvPolynomial σ R\n⊢ (rename k) (eval₂ C (g ∘ k) p) = eval₂ C (⇑(rename k) ∘ g) ((rename k) p)",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
"AddMon... | apply MvPolynomial.induction_on p <;>
· intros
simp [*] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.MvPolynomial.Rename | {
"line": 281,
"column": 2
} | {
"line": 283,
"column": 14
} | [
{
"pp": "σ : Type u_1\nτ : Type u_2\nR : Type u_4\ninst✝ : CommSemiring R\np : MvPolynomial σ R\nj : τ\ng : σ → MvPolynomial σ R\n⊢ (rename (Prod.mk j)) (eval₂ C g p) = eval₂ C (fun x ↦ (rename (Prod.mk j)) (g x)) p",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
"... | apply MvPolynomial.induction_on p <;>
· intros
simp [*] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.MvPolynomial.Rename | {
"line": 281,
"column": 2
} | {
"line": 283,
"column": 14
} | [
{
"pp": "σ : Type u_1\nτ : Type u_2\nR : Type u_4\ninst✝ : CommSemiring R\np : MvPolynomial σ R\nj : τ\ng : σ → MvPolynomial σ R\n⊢ (rename (Prod.mk j)) (eval₂ C g p) = eval₂ C (fun x ↦ (rename (Prod.mk j)) (g x)) p",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
"... | apply MvPolynomial.induction_on p <;>
· intros
simp [*] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MvPolynomial.Rename | {
"line": 281,
"column": 2
} | {
"line": 283,
"column": 14
} | [
{
"pp": "σ : Type u_1\nτ : Type u_2\nR : Type u_4\ninst✝ : CommSemiring R\np : MvPolynomial σ R\nj : τ\ng : σ → MvPolynomial σ R\n⊢ (rename (Prod.mk j)) (eval₂ C g p) = eval₂ C (fun x ↦ (rename (Prod.mk j)) (g x)) p",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
"... | apply MvPolynomial.induction_on p <;>
· intros
simp [*] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.MvPolynomial.Rename | {
"line": 287,
"column": 2
} | {
"line": 289,
"column": 14
} | [
{
"pp": "σ : Type u_1\nτ : Type u_2\nR : Type u_4\nS : Type u_5\ninst✝¹ : CommSemiring R\ninst✝ : CommSemiring S\nf : R →+* S\ng : σ × τ → S\ni : σ\np : MvPolynomial τ R\n⊢ eval₂ f g ((rename (Prod.mk i)) p) = eval₂ f (fun j ↦ g (i, j)) p",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.ins... | apply MvPolynomial.induction_on p <;>
· intros
simp [*] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.MvPolynomial.Rename | {
"line": 287,
"column": 2
} | {
"line": 289,
"column": 14
} | [
{
"pp": "σ : Type u_1\nτ : Type u_2\nR : Type u_4\nS : Type u_5\ninst✝¹ : CommSemiring R\ninst✝ : CommSemiring S\nf : R →+* S\ng : σ × τ → S\ni : σ\np : MvPolynomial τ R\n⊢ eval₂ f g ((rename (Prod.mk i)) p) = eval₂ f (fun j ↦ g (i, j)) p",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.ins... | apply MvPolynomial.induction_on p <;>
· intros
simp [*] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MvPolynomial.Rename | {
"line": 287,
"column": 2
} | {
"line": 289,
"column": 14
} | [
{
"pp": "σ : Type u_1\nτ : Type u_2\nR : Type u_4\nS : Type u_5\ninst✝¹ : CommSemiring R\ninst✝ : CommSemiring S\nf : R →+* S\ng : σ × τ → S\ni : σ\np : MvPolynomial τ R\n⊢ eval₂ f g ((rename (Prod.mk i)) p) = eval₂ f (fun j ↦ g (i, j)) p",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.ins... | apply MvPolynomial.induction_on p <;>
· intros
simp [*] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finsupp.Fin | {
"line": 83,
"column": 23
} | {
"line": 83,
"column": 25
} | [
{
"pp": "n : ℕ\nM : Type u_1\ninst✝ : Zero M\ny : M\ns : Fin n →₀ M\nc : cons y s = 0\n⊢ (cons y s) 0 = 0",
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"instNeZeroNatHAdd_1",
"congrArg",
"id",
"Fin.instOfNat",
"instOfNatNat",
"instHAdd",
"HAdd.hA... | c, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Finsupp.Fin | {
"line": 93,
"column": 10
} | {
"line": 93,
"column": 12
} | [
{
"pp": "n : ℕ\nM : Type u_1\ninst✝ : Zero M\ny : M\ns : Fin n →₀ M\nh : cons y s ≠ 0\nh' : y = 0\nc : s = 0\n⊢ cons 0 s = 0",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Zero.toOfNat0",
... | c, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Degree.Lemmas | {
"line": 62,
"column": 18
} | {
"line": 62,
"column": 81
} | [
{
"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⊢ ↑(n * q.natDegree) ≤ ↑(p.natDegree * q.natDegree)",
"usedConstants": [
"Nat.instIsOrderedAddMonoid",
"HMul.hMul",
"Finset",
"Nat.mono_cast"... | by gcongr; exact le_natDegree_of_ne_zero (mem_support_iff.1 hn) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Degree.Lemmas | {
"line": 163,
"column": 2
} | {
"line": 163,
"column": 60
} | [
{
"pp": "case inl\nR : Type u\nm n : ℕ\ninst✝ : Semiring R\np : R[X]\npn : p.natDegree ≤ n\nmno : m * n ≤ m * n\n⊢ (p ^ m).coeff (m * n) = if m * n = m * n then p.coeff n ^ m else 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"instDecidableTrue",
"congrArg",
"id",
"instMu... | · simpa only [ite_true] using coeff_pow_of_natDegree_le pn | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Polynomial.Reverse | {
"line": 132,
"column": 18
} | {
"line": 132,
"column": 34
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\nr : R\nN : ℕ\n| reflect N (C r)",
"usedConstants": [
"Polynomial.C",
"MulOne.toOne",
"HMul.hMul",
"congrArg",
"RingHom",
"MulOne.toMul",
"Polynomial",
"MulZeroOneClass.toMulOneClass",
"instMulZeroOneClassOfSemir... | ← mul_one (C r), | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.Algebra.Polynomial.Reverse | {
"line": 251,
"column": 32
} | {
"line": 251,
"column": 76
} | [
{
"pp": "case neg.a.h\nR : Type u_1\ninst✝ : Semiring R\nf : R[X]\nhf : ¬f = 0\n⊢ f.coeff ((revAt f.natDegree) (f.natDegree - f.natTrailingDegree)) ≠ 0",
"usedConstants": [
"Eq.mpr",
"Polynomial.revAt",
"congrArg",
"HSub.hSub",
"id",
"instSubNat",
"Ne",
"Polyn... | ← revAt_le f.natTrailingDegree_le_natDegree, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Reverse | {
"line": 262,
"column": 39
} | {
"line": 262,
"column": 83
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\nf : R[X]\n⊢ f.reverse.coeff (f.natDegree - f.natTrailingDegree) = f.trailingCoeff",
"usedConstants": [
"Eq.mpr",
"Polynomial.revAt",
"congrArg",
"HSub.hSub",
"id",
"instSubNat",
"Polynomial.revAt_le",
"Polynomial.coef... | ← revAt_le f.natTrailingDegree_le_natDegree, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.MvPolynomial.Equiv | {
"line": 366,
"column": 4
} | {
"line": 366,
"column": 68
} | [
{
"pp": "case hgfC\nR : Type u\nS₁ : Type v\nS₂ : Type w\nS₃ : Type x\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\ns : σ →₀ ℕ\ninst✝ : CommSemiring R\n⊢ ((iterToSum R S₁ S₂).comp (sumToIter R S₁ S₂)).comp C = C",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
"MvPolynomial... | ext1; simp only [RingHom.comp_apply, sumToIter_C, iterToSum_C_C] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MvPolynomial.Equiv | {
"line": 366,
"column": 4
} | {
"line": 366,
"column": 68
} | [
{
"pp": "case hgfC\nR : Type u\nS₁ : Type v\nS₂ : Type w\nS₃ : Type x\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\ns : σ →₀ ℕ\ninst✝ : CommSemiring R\n⊢ ((iterToSum R S₁ S₂).comp (sumToIter R S₁ S₂)).comp C = C",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
"MvPolynomial... | ext1; simp only [RingHom.comp_apply, sumToIter_C, iterToSum_C_C] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.EraseLead | {
"line": 363,
"column": 4
} | {
"line": 371,
"column": 30
} | [
{
"pp": "case refine_2\nR : Type u_1\ninst✝³ : Semiring R\nS : Type u_2\nF : Type u_3\ninst✝² : Semiring S\ninst✝¹ : FunLike F R[X] S[X]\ninst✝ : AddMonoidHomClass F R[X] S[X]\nφ : F\np : R[X]\nk : ℕ\nfu : ℕ → ℕ\nfu0 : ∀ {n : ℕ}, n ≤ k → fu n = 0\nfc : ∀ {n m : ℕ}, k ≤ n → n < m → fu n < fu m\nφ_k : ∀ {f : R[X]... | intro f g fg _ fk gk
rw [natDegree_add_eq_right_of_natDegree_lt fg, map_add]
by_cases! FG : k ≤ f.natDegree
· rw [natDegree_add_eq_right_of_natDegree_lt, gk]
rw [fk, gk]
exact fc FG fg
· cases k
· nomatch FG
· rwa [φ_k FG, zero_add] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.EraseLead | {
"line": 363,
"column": 4
} | {
"line": 371,
"column": 30
} | [
{
"pp": "case refine_2\nR : Type u_1\ninst✝³ : Semiring R\nS : Type u_2\nF : Type u_3\ninst✝² : Semiring S\ninst✝¹ : FunLike F R[X] S[X]\ninst✝ : AddMonoidHomClass F R[X] S[X]\nφ : F\np : R[X]\nk : ℕ\nfu : ℕ → ℕ\nfu0 : ∀ {n : ℕ}, n ≤ k → fu n = 0\nfc : ∀ {n m : ℕ}, k ≤ n → n < m → fu n < fu m\nφ_k : ∀ {f : R[X]... | intro f g fg _ fk gk
rw [natDegree_add_eq_right_of_natDegree_lt fg, map_add]
by_cases! FG : k ≤ f.natDegree
· rw [natDegree_add_eq_right_of_natDegree_lt, gk]
rw [fk, gk]
exact fc FG fg
· cases k
· nomatch FG
· rwa [φ_k FG, zero_add] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.MvPolynomial.Equiv | {
"line": 549,
"column": 8
} | {
"line": 549,
"column": 10
} | [
{
"pp": "case pos\nR : Type u\nσ : Type u_1\ninst✝ : CommSemiring R\np : MvPolynomial (Option σ) R\nc : p = 0\n⊢ ((optionEquivLeft R σ) p).natDegree = degreeOf none p",
"usedConstants": [
"Eq.mpr",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"congrArg",
"CommSemiring.t... | c, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.BigOperators | {
"line": 279,
"column": 4
} | {
"line": 279,
"column": 76
} | [
{
"pp": "case h.e'_2.hnc\nR : Type u\ninst✝ : CommRing R\nt : Multiset R\nht : 0 < t.card\na✝ : Nontrivial R\nx : R\nhx : x ∈ t\n⊢ ¬∀ (x : ℕ), (∃ a, (∃ a_1 ∈ t, X - C a_1 = a) ∧ a.natDegree = x) → x = 0",
"usedConstants": [
"Polynomial.C",
"Nat.instOne",
"CommSemiring.toSemiring",
"A... | exact fun h => one_ne_zero <| h 1 ⟨_, ⟨x, hx, rfl⟩, natDegree_X_sub_C _⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.MvPolynomial.Equiv | {
"line": 792,
"column": 8
} | {
"line": 792,
"column": 10
} | [
{
"pp": "case pos\nR : Type u\ninst✝ : CommSemiring R\nn : ℕ\nf : MvPolynomial (Fin (n + 1)) R\nc : f = 0\n⊢ ((finSuccEquiv R n) f).natDegree = degreeOf 0 f",
"usedConstants": [
"Eq.mpr",
"instNeZeroNatHAdd_1",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"congrArg",
... | c, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.BigOperators | {
"line": 379,
"column": 6
} | {
"line": 379,
"column": 30
} | [
{
"pp": "R : Type u\ninst✝¹ : CommSemiring R\ninst✝ : NoZeroDivisors R\nt : Multiset R[X]\nh : 0 ∉ t\na✝ : Nontrivial R\n⊢ t.prod.natDegree = (Multiset.map natDegree t).sum",
"usedConstants": [
"Multiset.sum",
"Eq.mpr",
"Multiset.map",
"congrArg",
"CommSemiring.toSemiring",
... | natDegree_multiset_prod' | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 122,
"column": 19
} | {
"line": 126,
"column": 7
} | [
{
"pp": "R✝ : Type u\nS : Type u_1\ninst✝¹ : Semiring R✝\nR : Type ?u.7131\ninst✝ : Semiring R\nn : ℕ\nx : R\np : ↥(degreeLT R n)\n⊢ (fun n_1 ↦ (↑(x • p)).coeff ↑n_1) = (RingHom.id R) x • fun n_1 ↦ (↑p).coeff ↑n_1",
"usedConstants": [
"Eq.mpr",
"Pi.Function.module",
"Polynomial.degreeLT",
... | by
ext
dsimp
rw [coeff_smul]
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 157,
"column": 13
} | {
"line": 157,
"column": 20
} | [
{
"pp": "case pos\nR : Type u\ninst✝ : Semiring R\nn : ℕ\nx : R[X]\nx_zero : x = 0\n⊢ x ∈ degreeLT R (n + 1) ↔ x ∈ degreeLE R ↑n",
"usedConstants": [
"Eq.mpr",
"Polynomial.degreeLT",
"Submodule",
"WithBot",
"Semiring.toModule",
"congrArg",
"Polynomial.degreeLE",
... | x_zero, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 167,
"column": 4
} | {
"line": 167,
"column": 28
} | [
{
"pp": "R : Type u\nS : Type u_1\ninst✝¹ : Semiring R\ninst✝ : Nontrivial R\np : R[X]\nhp : p.Monic\n⊢ (↑⟨p, ⋯⟩).eraseLead ∈ degreeLT R p.natDegree",
"usedConstants": [
"WithBot.instPreorder",
"Eq.mpr",
"Polynomial.degreeLT",
"Submodule",
"WithBot",
"Preorder.toLT",
... | simp only [mem_degreeLT] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.RingTheory.Adjoin.FG | {
"line": 129,
"column": 2
} | {
"line": 129,
"column": 21
} | [
{
"pp": "R : Type u\nA : Type v\nB : Type w\ninst✝⁴ : CommSemiring R\ninst✝³ : Semiring A\ninst✝² : Algebra R A\ninst✝¹ : Semiring B\ninst✝ : Algebra R B\nS : Subalgebra R A\nT : Subalgebra R B\nhS : S.FG\nhT : T.FG\ns : Set A\nhs : s.Finite ∧ Algebra.adjoin R s = S\nt : Set B\nht : t.Finite ∧ Algebra.adjoin R ... | rw [← hs.2, ← ht.2] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 235,
"column": 2
} | {
"line": 235,
"column": 42
} | [
{
"pp": "R : Type u\ninst✝¹ : Semiring R\ninst✝ : Nontrivial R\n⊢ ¬Module.Finite R R[X]",
"usedConstants": [
"Eq.mpr",
"Submodule",
"Semiring.toModule",
"congrArg",
"Submodule.fg_def",
"Set.Finite",
"Exists",
"id",
"Submodule.instTop",
"Polynomial"... | rw [Module.finite_def, Submodule.fg_def] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 431,
"column": 4
} | {
"line": 431,
"column": 55
} | [
{
"pp": "case mpr\nR : Type u\ninst✝ : CommSemiring R\nI : Ideal R\nf : R[X]\nhf : ∀ (n : ℕ), f.coeff n ∈ I\n⊢ (f.sum fun n a ↦ (monomial n) a) ∈ map C I",
"usedConstants": [
"Polynomial.C",
"Semiring.toModule",
"CommSemiring.toSemiring",
"Finset",
"LinearMap.instFunLike",
... | refine (I.map C : Ideal R[X]).sum_mem fun n _ => ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 779,
"column": 34
} | {
"line": 779,
"column": 45
} | [
{
"pp": "R : Type u\nσ : Type v\ninst✝ : CommRing R\ns : Set σ\np : MvPolynomial (↑s) R\neqv : MvPolynomial (↑sᶜ) (MvPolynomial (↑s) R) ≃ₐ[R] MvPolynomial σ R :=\n (sumAlgEquiv R ↑sᶜ ↑s).symm.trans (renameEquiv R ((Equiv.sumComm ↑sᶜ ↑s).trans (Equiv.Set.sumCompl s)))\nthis : (rename Subtype.val) p = eqv (C p)\... | prime_C_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.FiniteType | {
"line": 189,
"column": 2
} | {
"line": 189,
"column": 23
} | [
{
"pp": "R : Type u_1\nS : Type u_2\ninst✝³ : CommRing R\ninst✝² : CommRing S\ninst✝¹ : Algebra R S\nh : FiniteType R S\ninst✝ : IsNoetherianRing R\n⊢ IsNoetherianRing S",
"usedConstants": [
"CommSemiring.toSemiring",
"CommRing.toCommSemiring",
"Algebra.FiniteType.out"
]
}
] | obtain ⟨s, hs⟩ := h.1 | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.RingTheory.FiniteType | {
"line": 406,
"column": 4
} | {
"line": 406,
"column": 33
} | [
{
"pp": "case hsmul\nR : Type u_1\nM : Type u_2\ninst✝¹ : AddCommMonoid M\ninst✝ : CommSemiring R\nS : Set M\nhS : closure S = ⊤\nr : R\nP : MvPolynomial (↑S) R\n⊢ ∃ a, (MvPolynomial.aeval fun s ↦ of' R M ↑s) a = r • (MvPolynomial.aeval fun s ↦ of' R M ↑s) P",
"usedConstants": [
"NonAssocSemiring.toAd... | exact ⟨r • P, map_smul _ _ _⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.FiniteType | {
"line": 387,
"column": 80
} | {
"line": 406,
"column": 33
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝¹ : AddCommMonoid M\ninst✝ : CommSemiring R\nS : Set M\nhS : closure S = ⊤\n⊢ Surjective ⇑(MvPolynomial.aeval fun s ↦ of' R M ↑s)",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"AddMonoid... | by
intro f
induction f using induction_on with
| hM m =>
have : m ∈ closure S := hS.symm ▸ mem_top _
refine AddSubmonoid.closure_induction (fun m hm => ?_) ?_ ?_ this
· exact ⟨MvPolynomial.X ⟨m, hm⟩, MvPolynomial.aeval_X _ _⟩
· exact ⟨1, map_one _⟩
· rintro m₁ m₂ _ _ ⟨P₁, hP₁⟩ ⟨P₂, hP₂⟩
... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.FiniteType | {
"line": 434,
"column": 4
} | {
"line": 434,
"column": 33
} | [
{
"pp": "case hsmul\nR : Type u_1\nM : Type u_2\ninst✝¹ : AddMonoid M\ninst✝ : CommSemiring R\nS : Set M\nhS : closure S = ⊤\nr : R\nP : FreeAlgebra R ↑S\n⊢ ∃ a, ((FreeAlgebra.lift R) fun s ↦ of' R M ↑s) a = r • ((FreeAlgebra.lift R) fun s ↦ of' R M ↑s) P",
"usedConstants": [
"NonAssocSemiring.toAddCo... | exact ⟨r • P, map_smul _ _ _⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.FiniteType | {
"line": 557,
"column": 4
} | {
"line": 557,
"column": 33
} | [
{
"pp": "case hsmul\nR : Type u_1\nM : Type u_2\ninst✝¹ : CommMonoid M\ninst✝ : CommSemiring R\nS : Set M\nhS : closure S = ⊤\nr : R\nP : MvPolynomial (↑S) R\n⊢ ∃ a, (MvPolynomial.aeval fun s ↦ (of R M) ↑s) a = r • (MvPolynomial.aeval fun s ↦ (of R M) ↑s) P",
"usedConstants": [
"MonoidAlgebra.semiring... | exact ⟨r • P, map_smul _ _ _⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.FiniteType | {
"line": 585,
"column": 4
} | {
"line": 585,
"column": 33
} | [
{
"pp": "case hsmul\nR : Type u_1\nM : Type u_2\ninst✝¹ : Monoid M\ninst✝ : CommSemiring R\nS : Set M\nhS : closure S = ⊤\nr : R\nP : FreeAlgebra R ↑S\n⊢ ∃ a, ((FreeAlgebra.lift R) fun s ↦ (of R M) ↑s) a = r • ((FreeAlgebra.lift R) fun s ↦ (of R M) ↑s) P",
"usedConstants": [
"MonoidAlgebra.semiring",
... | exact ⟨r • P, map_smul _ _ _⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Algebra.Subalgebra.Rank | {
"line": 50,
"column": 2
} | {
"line": 50,
"column": 96
} | [
{
"pp": "R : Type u_1\nS : Type u_2\ninst✝⁴ : CommRing R\ninst✝³ : CommRing S\ninst✝² : Algebra R S\nA B : Subalgebra R S\ninst✝¹ : Free R ↥A\ninst✝ : Free ↥A ↥(Algebra.adjoin ↥A ↑B)\n⊢ finrank R ↥(A ⊔ B) = finrank R ↥A * finrank ↥A ↥(Algebra.adjoin ↥A ↑B)",
"usedConstants": [
"Subalgebra.instSetLike"... | simpa only [map_mul] using congr(Cardinal.toNat $(rank_sup_eq_rank_left_mul_rank_of_free A B)) | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Algebra.Subalgebra.Rank | {
"line": 50,
"column": 2
} | {
"line": 50,
"column": 96
} | [
{
"pp": "R : Type u_1\nS : Type u_2\ninst✝⁴ : CommRing R\ninst✝³ : CommRing S\ninst✝² : Algebra R S\nA B : Subalgebra R S\ninst✝¹ : Free R ↥A\ninst✝ : Free ↥A ↥(Algebra.adjoin ↥A ↑B)\n⊢ finrank R ↥(A ⊔ B) = finrank R ↥A * finrank ↥A ↥(Algebra.adjoin ↥A ↑B)",
"usedConstants": [
"Subalgebra.instSetLike"... | simpa only [map_mul] using congr(Cardinal.toNat $(rank_sup_eq_rank_left_mul_rank_of_free A B)) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Algebra.Subalgebra.Rank | {
"line": 50,
"column": 2
} | {
"line": 50,
"column": 96
} | [
{
"pp": "R : Type u_1\nS : Type u_2\ninst✝⁴ : CommRing R\ninst✝³ : CommRing S\ninst✝² : Algebra R S\nA B : Subalgebra R S\ninst✝¹ : Free R ↥A\ninst✝ : Free ↥A ↥(Algebra.adjoin ↥A ↑B)\n⊢ finrank R ↥(A ⊔ B) = finrank R ↥A * finrank ↥A ↥(Algebra.adjoin ↥A ↑B)",
"usedConstants": [
"Subalgebra.instSetLike"... | simpa only [map_mul] using congr(Cardinal.toNat $(rank_sup_eq_rank_left_mul_rank_of_free A B)) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.ModEq | {
"line": 172,
"column": 24
} | {
"line": 172,
"column": 65
} | [
{
"pp": "n a b : ℤ\nh : a ≡ b [ZMOD n]\n⊢ a + -a ≡ b + -b [ZMOD n]",
"usedConstants": [
"Eq.mpr",
"sub_self",
"congrArg",
"AddMonoid.toAddZeroClass",
"HSub.hSub",
"AddZeroClass.toAddZero",
"id",
"instHMod",
"_private.Mathlib.Data.Int.ModEq.0.Int.ModEq.ne... | simp_rw [← sub_eq_add_neg, sub_self]; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Int.ModEq | {
"line": 172,
"column": 24
} | {
"line": 172,
"column": 65
} | [
{
"pp": "n a b : ℤ\nh : a ≡ b [ZMOD n]\n⊢ a + -a ≡ b + -b [ZMOD n]",
"usedConstants": [
"Eq.mpr",
"sub_self",
"congrArg",
"AddMonoid.toAddZeroClass",
"HSub.hSub",
"AddZeroClass.toAddZero",
"id",
"instHMod",
"_private.Mathlib.Data.Int.ModEq.0.Int.ModEq.ne... | simp_rw [← sub_eq_add_neg, sub_self]; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.ModEq | {
"line": 222,
"column": 50
} | {
"line": 222,
"column": 76
} | [
{
"pp": "case h.e'_1\nm a b c : ℤ\nh : a / c ≡ b / c [ZMOD m / c]\nha✝¹ : c ∣ a\nha✝ : c ∣ b\nha : c ∣ m\n⊢ m = ?m.24 * (m / c)",
"usedConstants": [
"Eq.mpr",
"Int.instDiv",
"instHDiv",
"HMul.hMul",
"congrArg",
"id",
"HDiv.hDiv",
"Int",
"Int.instMul",
... | rwa [Int.mul_ediv_cancel'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Data.Int.ModEq | {
"line": 222,
"column": 50
} | {
"line": 222,
"column": 76
} | [
{
"pp": "case h.e'_2\nm a b c : ℤ\nh : a / c ≡ b / c [ZMOD m / c]\nha✝¹ : c ∣ a\nha✝ : c ∣ b\nha : c ∣ m\n⊢ a = c * (a / c)",
"usedConstants": [
"Eq.mpr",
"Int.instDiv",
"instHDiv",
"HMul.hMul",
"congrArg",
"id",
"HDiv.hDiv",
"Int",
"Int.instMul",
... | rwa [Int.mul_ediv_cancel'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Data.Int.ModEq | {
"line": 222,
"column": 50
} | {
"line": 222,
"column": 76
} | [
{
"pp": "case h.e'_3\nm a b c : ℤ\nh : a / c ≡ b / c [ZMOD m / c]\nha✝¹ : c ∣ a\nha✝ : c ∣ b\nha : c ∣ m\n⊢ b = c * (b / c)",
"usedConstants": [
"Eq.mpr",
"Int.instDiv",
"instHDiv",
"HMul.hMul",
"congrArg",
"id",
"HDiv.hDiv",
"Int",
"Int.instMul",
... | rwa [Int.mul_ediv_cancel'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Data.Int.ModEq | {
"line": 272,
"column": 6
} | {
"line": 272,
"column": 17
} | [
{
"pp": "n a b : ℤ\n⊢ a ≡ a + b [ZMOD n] ↔ n ∣ b",
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"congrArg",
"Int.modEq_comm",
"id",
"Int",
"Int.instDvd",
"instHAdd",
"Iff",
"HAdd.hAdd",
"Int.ModEq",
"propext",
"Int.instAdd",
"Eq"... | modEq_comm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Int.ModEq | {
"line": 276,
"column": 6
} | {
"line": 276,
"column": 17
} | [
{
"pp": "n a b : ℤ\n⊢ b ≡ a + b [ZMOD n] ↔ n ∣ a",
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"congrArg",
"Int.modEq_comm",
"id",
"Int",
"Int.instDvd",
"instHAdd",
"Iff",
"HAdd.hAdd",
"Int.ModEq",
"propext",
"Int.instAdd",
"Eq"... | modEq_comm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.CharP.Basic | {
"line": 185,
"column": 14
} | {
"line": 185,
"column": 32
} | [
{
"pp": "case inl\nR : Type u_1\ninst✝² : NonAssocRing R\ninst✝¹ : NoZeroDivisors R\ninst✝ : Nontrivial R\nh : ∀ (p : ℕ), Nat.Prime p → ↑p ≠ 0\np : ℕ := ringChar R\nhp : Nat.Prime p\n⊢ CharZero R",
"usedConstants": [
"CharP.cast_eq_zero",
"False",
"congrArg",
"False.elim",
"Add... | simpa using h p hp | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.CharP.Basic | {
"line": 185,
"column": 14
} | {
"line": 185,
"column": 32
} | [
{
"pp": "case inl\nR : Type u_1\ninst✝² : NonAssocRing R\ninst✝¹ : NoZeroDivisors R\ninst✝ : Nontrivial R\nh : ∀ (p : ℕ), Nat.Prime p → ↑p ≠ 0\np : ℕ := ringChar R\nhp : Nat.Prime p\n⊢ CharZero R",
"usedConstants": [
"CharP.cast_eq_zero",
"False",
"congrArg",
"False.elim",
"Add... | simpa using h p hp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.CharP.Basic | {
"line": 185,
"column": 14
} | {
"line": 185,
"column": 32
} | [
{
"pp": "case inl\nR : Type u_1\ninst✝² : NonAssocRing R\ninst✝¹ : NoZeroDivisors R\ninst✝ : Nontrivial R\nh : ∀ (p : ℕ), Nat.Prime p → ↑p ≠ 0\np : ℕ := ringChar R\nhp : Nat.Prime p\n⊢ CharZero R",
"usedConstants": [
"CharP.cast_eq_zero",
"False",
"congrArg",
"False.elim",
"Add... | simpa using h p hp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fintype.List | {
"line": 83,
"column": 8
} | {
"line": 88,
"column": 12
} | [
{
"pp": "case h.e.h.a.mp\nα : Type u_1\ninst✝ : Fintype α\nunivSubsets : Multiset (Finset α) := ⋯\nallPerms : Multiset (List α) := ⋯\nl : List (Finset α)\nm n : Finset α\nthis :\n (∀ ⦃x : Multiset (List α)⦄, x ≤ ↑m.toList.permutations → x ≤ ↑n.toList.permutations → x ≤ ⊥) ↔\n m.toList.permutations.Disjoint ... | intro h
by_contra hc
rw [hc] at h
contrapose! h
use n.toList
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fintype.List | {
"line": 83,
"column": 8
} | {
"line": 88,
"column": 12
} | [
{
"pp": "case h.e.h.a.mp\nα : Type u_1\ninst✝ : Fintype α\nunivSubsets : Multiset (Finset α) := ⋯\nallPerms : Multiset (List α) := ⋯\nl : List (Finset α)\nm n : Finset α\nthis :\n (∀ ⦃x : Multiset (List α)⦄, x ≤ ↑m.toList.permutations → x ≤ ↑n.toList.permutations → x ≤ ⊥) ↔\n m.toList.permutations.Disjoint ... | intro h
by_contra hc
rw [hc] at h
contrapose! h
use n.toList
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Star.Subalgebra | {
"line": 333,
"column": 49
} | {
"line": 333,
"column": 64
} | [
{
"pp": "R : Type u_2\nA : Type u_3\ninst✝⁵ : CommSemiring R\ninst✝⁴ : StarRing R\ninst✝³ : Semiring A\ninst✝² : StarRing A\ninst✝¹ : Algebra R A\ninst✝ : StarModule R A\ns : Set A\n⊢ (↑(centralizer R s) ∪ ↑(centralizer R s)).centralizer = (s ∪ star s).centralizer.centralizer",
"usedConstants": [
"Eq.... | Set.union_self, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.PeriodicPts.Lemmas | {
"line": 77,
"column": 4
} | {
"line": 77,
"column": 54
} | [
{
"pp": "case refine_2\nα : Type u_1\nf✝ : α → α\nx : α\ng✝ : α → α\nh✝ : Function.Commute f✝ g✝\nhco✝ : (minimalPeriod f✝ x).Coprime (minimalPeriod g✝ x)\nf g : α → α\nh : Function.Commute f g\nhco : (minimalPeriod f x).Coprime (minimalPeriod g x)\n⊢ IsPeriodicPt g (minimalPeriod g x * minimalPeriod (f ∘ g) x)... | exact (isPeriodicPt_minimalPeriod _ _).mul_const _ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Dynamics.PeriodicPts.Lemmas | {
"line": 77,
"column": 4
} | {
"line": 77,
"column": 54
} | [
{
"pp": "case refine_2\nα : Type u_1\nf✝ : α → α\nx : α\ng✝ : α → α\nh✝ : Function.Commute f✝ g✝\nhco✝ : (minimalPeriod f✝ x).Coprime (minimalPeriod g✝ x)\nf g : α → α\nh : Function.Commute f g\nhco : (minimalPeriod f x).Coprime (minimalPeriod g x)\n⊢ IsPeriodicPt g (minimalPeriod g x * minimalPeriod (f ∘ g) x)... | exact (isPeriodicPt_minimalPeriod _ _).mul_const _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.PeriodicPts.Lemmas | {
"line": 77,
"column": 4
} | {
"line": 77,
"column": 54
} | [
{
"pp": "case refine_2\nα : Type u_1\nf✝ : α → α\nx : α\ng✝ : α → α\nh✝ : Function.Commute f✝ g✝\nhco✝ : (minimalPeriod f✝ x).Coprime (minimalPeriod g✝ x)\nf g : α → α\nh : Function.Commute f g\nhco : (minimalPeriod f x).Coprime (minimalPeriod g x)\n⊢ IsPeriodicPt g (minimalPeriod g x * minimalPeriod (f ∘ g) x)... | exact (isPeriodicPt_minimalPeriod _ _).mul_const _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Permutation | {
"line": 338,
"column": 22
} | {
"line": 338,
"column": 36
} | [
{
"pp": "case cons.p\nα : Type u_1\na b c : α\nl : List α\nih : flatMap (permutations'Aux b) (permutations'Aux a l) ~ flatMap (permutations'Aux a) (permutations'Aux b l)\nthis :\n ∀ (a b : α),\n flatMap (permutations'Aux b) (map (cons c) (permutations'Aux a l)) ~\n map (cons b ∘ cons c) (permutations'A... | ← append_assoc | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Cycle | {
"line": 380,
"column": 48
} | {
"line": 380,
"column": 75
} | [
{
"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⊢ l.reverse.prev l.reverse[l.length - 1 - k] ⋯ = (pmap l.next l ⋯)[k]",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"congrArg"... | pmap_next_eq_rotate_one _ h | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.List.Cycle | {
"line": 548,
"column": 42
} | {
"line": 548,
"column": 47
} | [
{
"pp": "case h\nα : Type u_1\nl : List α\nh : Subsingleton (Quot.mk (⇑(IsRotated.setoid α)) l)\n⊢ ∀ ⦃x : α⦄, x ∈ Quot.mk (⇑(IsRotated.setoid α)) l → ∀ ⦃y : α⦄, y ∈ Quot.mk (⇑(IsRotated.setoid α)) l → x = y",
"usedConstants": []
}
] | | _ l
=> | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.List.Cycle | {
"line": 564,
"column": 4
} | {
"line": 568,
"column": 22
} | [
{
"pp": "case cons.cons\nα : Type u_1\nhd hd' : α\ntl : List α\nhl : (hd :: hd' :: tl).Nodup\n⊢ (∃ x y, x ≠ y ∧ x ∈ ↑(hd :: hd' :: tl) ∧ y ∈ ↑(hd :: hd' :: tl)) ↔ 2 ≤ (hd :: hd' :: tl).length",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.Data.List.Cycle.0.Cycle.nontrivial_coe_nodup_iff._simp_... | simp only [mem_cons, mem_coe_iff, List.length, Ne, Nat.succ_le_succ_iff,
Nat.zero_le, iff_true]
refine ⟨hd, hd', ?_, by simp⟩
simp only [not_or, mem_cons, nodup_cons] at hl
exact hl.left.left | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Cycle | {
"line": 564,
"column": 4
} | {
"line": 568,
"column": 22
} | [
{
"pp": "case cons.cons\nα : Type u_1\nhd hd' : α\ntl : List α\nhl : (hd :: hd' :: tl).Nodup\n⊢ (∃ x y, x ≠ y ∧ x ∈ ↑(hd :: hd' :: tl) ∧ y ∈ ↑(hd :: hd' :: tl)) ↔ 2 ≤ (hd :: hd' :: tl).length",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.Data.List.Cycle.0.Cycle.nontrivial_coe_nodup_iff._simp_... | simp only [mem_cons, mem_coe_iff, List.length, Ne, Nat.succ_le_succ_iff,
Nat.zero_le, iff_true]
refine ⟨hd, hd', ?_, by simp⟩
simp only [not_or, mem_cons, nodup_cons] at hl
exact hl.left.left | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Cycle | {
"line": 576,
"column": 42
} | {
"line": 576,
"column": 47
} | [
{
"pp": "case h\nα : Type u_1\nx y : α\nhxy : x ≠ y\nl : List α\nhx : x ∈ Quot.mk (⇑(IsRotated.setoid α)) l\nhy : y ∈ Quot.mk (⇑(IsRotated.setoid α)) l\n⊢ 2 ≤ length (Quot.mk (⇑(IsRotated.setoid α)) l)",
"usedConstants": []
}
] | | _ l
=> | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.List.Cycle | {
"line": 600,
"column": 42
} | {
"line": 600,
"column": 47
} | [
{
"pp": "case h\nα : Type u_1\nl : List α\nh : Subsingleton (Quot.mk (⇑(IsRotated.setoid α)) l)\n⊢ Nodup (Quot.mk (⇑(IsRotated.setoid α)) l)",
"usedConstants": []
}
] | | _ l
=> | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.List.Cycle | {
"line": 735,
"column": 41
} | {
"line": 735,
"column": 77
} | [
{
"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 α)... | simpa using isRotated_next_eq h h₁ _ | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.GroupTheory.GroupAction.Basic | {
"line": 277,
"column": 2
} | {
"line": 277,
"column": 48
} | [
{
"pp": "G : Type u_1\nα : Type u_2\ninst✝¹ : Group G\ninst✝ : MulAction G α\ng h k : G\na b c : α\nhg : b = g • a\nhh : c = h • b\nhk : c = k • a\nH : k = h * g\n⊢ (stabilizerEquivStabilizer hg).trans (stabilizerEquivStabilizer hh) = stabilizerEquivStabilizer hk",
"usedConstants": [
"MulAction.stabil... | ext; simp [stabilizerEquivStabilizer_apply, H] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.GroupAction.Basic | {
"line": 277,
"column": 2
} | {
"line": 277,
"column": 48
} | [
{
"pp": "G : Type u_1\nα : Type u_2\ninst✝¹ : Group G\ninst✝ : MulAction G α\ng h k : G\na b c : α\nhg : b = g • a\nhh : c = h • b\nhk : c = k • a\nH : k = h * g\n⊢ (stabilizerEquivStabilizer hg).trans (stabilizerEquivStabilizer hh) = stabilizerEquivStabilizer hk",
"usedConstants": [
"MulAction.stabil... | ext; simp [stabilizerEquivStabilizer_apply, H] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.GroupAction.Basic | {
"line": 334,
"column": 2
} | {
"line": 334,
"column": 48
} | [
{
"pp": "G : Type u_1\nα : Type u_2\ninst✝¹ : AddGroup G\ninst✝ : AddAction G α\ng h k : G\na b c : α\nhg : b = g +ᵥ a\nhh : c = h +ᵥ b\nhk : c = k +ᵥ a\nH : k = h + g\n⊢ (stabilizerEquivStabilizer hg).trans (stabilizerEquivStabilizer hh) = stabilizerEquivStabilizer hk",
"usedConstants": [
"AddGroup.t... | ext; simp [stabilizerEquivStabilizer_apply, H] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.GroupAction.Basic | {
"line": 334,
"column": 2
} | {
"line": 334,
"column": 48
} | [
{
"pp": "G : Type u_1\nα : Type u_2\ninst✝¹ : AddGroup G\ninst✝ : AddAction G α\ng h k : G\na b c : α\nhg : b = g +ᵥ a\nhh : c = h +ᵥ b\nhk : c = k +ᵥ a\nH : k = h + g\n⊢ (stabilizerEquivStabilizer hg).trans (stabilizerEquivStabilizer hh) = stabilizerEquivStabilizer hk",
"usedConstants": [
"AddGroup.t... | ext; simp [stabilizerEquivStabilizer_apply, H] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Factors | {
"line": 158,
"column": 96
} | {
"line": 159,
"column": 44
} | [
{
"pp": "n p : ℕ\n⊢ p ∈ n.primeFactorsList ↔ Prime p ∧ p ∣ n ∧ n ≠ 0",
"usedConstants": [
"False",
"Nat.instMulZeroClass",
"Nat.Prime",
"Dvd.dvd",
"Nat.instOne",
"and_true",
"Nat.instSemigroupWithZero",
"congrArg",
"Nat.add_eq_zero_iff._simp_1",
"M... | by
cases n <;> simp [mem_primeFactorsList, *] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Factors | {
"line": 192,
"column": 2
} | {
"line": 193,
"column": 74
} | [
{
"pp": "n p : ℕ\nhpos : n ≠ 0\nh : ∀ {d : ℕ}, Prime d → d ∣ n → d = p\nk : ℕ := n.primeFactorsList.length\n⊢ n = p ^ k",
"usedConstants": [
"Eq.mpr",
"List.replicate",
"MulOne.toOne",
"Nat.prime_of_mem_primeFactorsList",
"Nat.instOne",
"Monoid.toMulOneClass",
"cong... | rw [← prod_primeFactorsList hpos, ← prod_replicate k p, eq_replicate_of_mem fun d hd =>
h (prime_of_mem_primeFactorsList hd) (dvd_of_mem_primeFactorsList hd)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Index | {
"line": 297,
"column": 2
} | {
"line": 298,
"column": 60
} | [
{
"pp": "G : Type u_1\nG' : Type u_2\ninst✝¹ : Group G\ninst✝ : Group G'\nf : G →* G'\nhf : Surjective ⇑f\n⊢ Nat.card G' ∣ Nat.card G",
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"Monoid.toMulOneClass",
"congrArg",
"Membership.mem",
"id",
"MulOne.toMul",
"Subtype... | rw [← Nat.card_congr (QuotientGroup.quotientKerEquivOfSurjective f hf).toEquiv]
exact Dvd.intro_left (Nat.card f.ker) f.ker.card_mul_index | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Index | {
"line": 297,
"column": 2
} | {
"line": 298,
"column": 60
} | [
{
"pp": "G : Type u_1\nG' : Type u_2\ninst✝¹ : Group G\ninst✝ : Group G'\nf : G →* G'\nhf : Surjective ⇑f\n⊢ Nat.card G' ∣ Nat.card G",
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"Monoid.toMulOneClass",
"congrArg",
"Membership.mem",
"id",
"MulOne.toMul",
"Subtype... | rw [← Nat.card_congr (QuotientGroup.quotientKerEquivOfSurjective f hf).toEquiv]
exact Dvd.intro_left (Nat.card f.ker) f.ker.card_mul_index | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Index | {
"line": 535,
"column": 69
} | {
"line": 536,
"column": 40
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\n⊢ H.index = 0 ↔ Infinite (G ⧸ H)",
"usedConstants": [
"False",
"congrArg",
"QuotientGroup.instInhabitedQuotientSubgroup",
"not_isEmpty_of_nonempty._simp_1",
"Nat.card",
"QuotientGroup.instHasQuotientSubgroup",
... | by
simp [index_eq_card, Nat.card_eq_zero] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Ring.GeomSum | {
"line": 187,
"column": 87
} | {
"line": 188,
"column": 32
} | [
{
"pp": "b : ℕ\nhb : 2 ≤ b\na n : ℕ\n⊢ a + ∑ i ∈ Ico 1 n.succ, a / b ^ i = a / b ^ 0 + ∑ i ∈ Ico 1 n.succ, a / b ^ i",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"instHDiv",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instMonoid",
"Nat.instLocallyFiniteOrder",
... | by
rw [pow_zero, Nat.div_one] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.ZMod.Basic | {
"line": 818,
"column": 2
} | {
"line": 819,
"column": 46
} | [
{
"pp": "m n : ℕ\n⊢ (m % n).Coprime n ↔ m.Coprime n",
"usedConstants": [
"Nat.gcd",
"Dvd.dvd",
"congrArg",
"Nat.instMonoid",
"semigroupDvd",
"Nat.instMod",
"instHMod",
"dvd_refl._simp_1",
"HMod.hMod",
"Nat.mod_mod_of_dvd",
"Nat",
"True"... | suffices (m % n).gcd n = m.gcd n by grind
exact Nat.ModEq.gcd_eq (by simp [Nat.ModEq]) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ZMod.Basic | {
"line": 818,
"column": 2
} | {
"line": 819,
"column": 46
} | [
{
"pp": "m n : ℕ\n⊢ (m % n).Coprime n ↔ m.Coprime n",
"usedConstants": [
"Nat.gcd",
"Dvd.dvd",
"congrArg",
"Nat.instMonoid",
"semigroupDvd",
"Nat.instMod",
"instHMod",
"dvd_refl._simp_1",
"HMod.hMod",
"Nat.mod_mod_of_dvd",
"Nat",
"True"... | suffices (m % n).gcd n = m.gcd n by grind
exact Nat.ModEq.gcd_eq (by simp [Nat.ModEq]) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.ZMod.Basic | {
"line": 936,
"column": 62
} | {
"line": 937,
"column": 58
} | [
{
"pp": "n : ℕ\n⊢ Nontrivial (ZMod n) ↔ n ≠ 1",
"usedConstants": [
"Nontrivial",
"Eq.mpr",
"congrArg",
"Iff.rfl",
"id",
"Ne",
"instOfNatNat",
"ZMod.subsingleton_iff",
"ZMod",
"Iff",
"Nat",
"propext",
"Subsingleton",
"not_sub... | by
rw [← not_subsingleton_iff_nontrivial, subsingleton_iff] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.ZMod.Basic | {
"line": 1250,
"column": 52
} | {
"line": 1250,
"column": 91
} | [
{
"pp": "G : Type u_2\ninst✝¹ : AddCommGroup G\ninst✝ : Module (ZMod 2) G\nx : G\n⊢ -x = x",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"_private.Mathlib.Data.ZMod.Basic.0.ZModModule.neg_eq_self._simp_1_1",
"congrArg",
"AddMonoid.toAddZeroClass",
... | simp [add_self, eq_comm, ← sub_eq_zero] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.ZMod.Basic | {
"line": 1250,
"column": 52
} | {
"line": 1250,
"column": 91
} | [
{
"pp": "G : Type u_2\ninst✝¹ : AddCommGroup G\ninst✝ : Module (ZMod 2) G\nx : G\n⊢ -x = x",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"_private.Mathlib.Data.ZMod.Basic.0.ZModModule.neg_eq_self._simp_1_1",
"congrArg",
"AddMonoid.toAddZeroClass",
... | simp [add_self, eq_comm, ← sub_eq_zero] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ZMod.Basic | {
"line": 1250,
"column": 52
} | {
"line": 1250,
"column": 91
} | [
{
"pp": "G : Type u_2\ninst✝¹ : AddCommGroup G\ninst✝ : Module (ZMod 2) G\nx : G\n⊢ -x = x",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"_private.Mathlib.Data.ZMod.Basic.0.ZModModule.neg_eq_self._simp_1_1",
"congrArg",
"AddMonoid.toAddZeroClass",
... | simp [add_self, eq_comm, ← sub_eq_zero] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 60,
"column": 2
} | {
"line": 64,
"column": 24
} | [
{
"pp": "case neg\nb : ℕ\nhb : 1 < b\nn : ℕ\nIH : ∀ m < n, m ≠ 0 → (b.digits m).length = log b m + 1\nhn : n ≠ 0\nh : ¬n / b = 0\n⊢ (b.digits (n / b)).length + 1 = log b n + 1",
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Mathlib.Tactic.Contrapose.contrapose₂",
"Na... | · have : n / b < n := div_lt_self (Nat.pos_of_ne_zero hn) hb
rw [IH _ this h, log_div_base, tsub_add_cancel_of_le]
refine Nat.succ_le_of_lt (log_pos hb ?_)
contrapose! h
exact div_eq_of_lt h | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 203,
"column": 6
} | {
"line": 207,
"column": 48
} | [
{
"pp": "case inl.inr\np n : ℕ\nh : 1 < p\nhn : n ≠ 0\n⊢ (p - 1) * ∑ i ∈ range (log p n).succ, n / p ^ i.succ = n - (p.digits n).sum",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Nat.instMulZeroClass",
"instHDiv",
"HMul.hMul",
"outParam",
"Nat.digits_lt_base",
"H... | convert!
sub_one_mul_sum_div_pow_eq_sub_sum_digits (p.digits n) (getLast_digit_ne_zero p hn) <|
(fun l a ↦ digits_lt_base h a)
· refine (length_digits p n h hn).symm
all_goals exact (ofDigits_digits p n).symm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 203,
"column": 6
} | {
"line": 207,
"column": 48
} | [
{
"pp": "case inl.inr\np n : ℕ\nh : 1 < p\nhn : n ≠ 0\n⊢ (p - 1) * ∑ i ∈ range (log p n).succ, n / p ^ i.succ = n - (p.digits n).sum",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Nat.instMulZeroClass",
"instHDiv",
"HMul.hMul",
"outParam",
"Nat.digits_lt_base",
"H... | convert!
sub_one_mul_sum_div_pow_eq_sub_sum_digits (p.digits n) (getLast_digit_ne_zero p hn) <|
(fun l a ↦ digits_lt_base h a)
· refine (length_digits p n h hn).symm
all_goals exact (ofDigits_digits p n).symm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 490,
"column": 2
} | {
"line": 490,
"column": 29
} | [
{
"pp": "b : ℕ\nhb : 1 < b\nl i : ℕ\nx✝² : i ∈ ↑(Finset.range b)\nj : ℕ\nx✝¹ : j ∈ ↑(Finset.range b)\nx✝ : (consFixedLengthDigits hb l i ∩ consFixedLengthDigits hb l j).Nonempty\nL : List ℕ\nhL : L ∈ consFixedLengthDigits hb l i ∩ consFixedLengthDigits hb l j\n⊢ i = j",
"usedConstants": [
"congrArg",
... | rw [Finset.mem_inter] at hL | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Multiplicity | {
"line": 199,
"column": 2
} | {
"line": 199,
"column": 28
} | [
{
"pp": "case succ\nα : Type u_1\ninst✝ : Monoid α\na b : α\nn✝ : ℕ\nhk : ↑(n✝ + 1) ≤ emultiplicity a b\n⊢ a ^ (n✝ + 1) ∣ b",
"usedConstants": []
}
] | unfold emultiplicity at hk | Lean.Elab.Tactic.evalUnfold | Lean.Parser.Tactic.unfold |
Mathlib.Algebra.CharP.Lemmas | {
"line": 41,
"column": 4
} | {
"line": 41,
"column": 36
} | [
{
"pp": "case h.e'_6.a\nR : Type u_1\ninst✝ : Semiring R\np : ℕ\nhp : Nat.Prime p\nx y : R\nh : Commute x y\nn k : ℕ\nhk : k ∈ Ioo 0 (p ^ n)\n⊢ x ^ k * y ^ (p ^ n - k) * ↑((p ^ n).choose k) = ↑p * (x ^ k * y ^ (p ^ n - k) * ↑((p ^ n).choose k / p))",
"usedConstants": [
"Preorder.toLT",
"Finset",... | obtain ⟨hk₀, hk⟩ := mem_Ioo.1 hk | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Algebra.CharP.Lemmas | {
"line": 54,
"column": 2
} | {
"line": 54,
"column": 34
} | [
{
"pp": "case h.e'_6.h.e'_6.a\nR : Type u_1\ninst✝ : Semiring R\np : ℕ\nhp : Nat.Prime p\nx y : R\nh : Commute x y\nn k : ℕ\nhk : k ∈ Ioo 0 (p ^ n)\n⊢ x ^ k * y ^ (p ^ n - k) * ↑((p ^ n).choose k / p) =\n x * y * (x ^ (k - 1) * y ^ (p ^ n - k - 1) * ↑((p ^ n).choose k / p))",
"usedConstants": [
"Pr... | obtain ⟨hk₀, hk⟩ := mem_Ioo.1 hk | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 518,
"column": 4
} | {
"line": 518,
"column": 35
} | [
{
"pp": "case pos\nn N : ℕ\nih : #({k ∈ Finset.range N.succ | k ≠ 0 ∧ n ∣ k}) = N / n\nh : n ∣ N.succ\n⊢ #(if N + 1 ≠ 0 ∧ n ∣ N + 1 then insert (N + 1) ({k ∈ Finset.range (N + 1) | k ≠ 0 ∧ n ∣ k})\n else {k ∈ Finset.range (N + 1) | k ≠ 0 ∧ n ∣ k}) =\n (N + 1) / n",
"usedConstants": [
"instDeci... | · simp [h, succ_div_of_dvd, ih] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.GroupTheory.OrderOfElement | {
"line": 414,
"column": 52
} | {
"line": 414,
"column": 74
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx : G\nn : ℕ\nhx : orderOf x ≠ 0\nhn : n ∣ orderOf x\n⊢ orderOf x / (orderOf x / n) = n",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"congrArg",
"id",
"HDiv.hDiv",
"orderOf",
"Nat",
"Nat.instDiv",
"Eq",
"Nat.d... | Nat.div_div_self hn hx | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Div | {
"line": 74,
"column": 6
} | {
"line": 74,
"column": 46
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np q : R[X]\nhp : 0 < p.degree\nhmp : p.Monic\nhq : q ≠ 0\nzn0 : 0 ≠ 1\nx✝ : p ^ (q.natDegree + 1) ∣ q\nr : R[X]\nhr : q = p ^ (q.natDegree + 1) * r\nhp0 : p ≠ 0\nhr0 : r ≠ 0\nhpn1 : p.leadingCoeff ^ (q.natDegree + 1) = 1\nhpn0' : p.leadingCoeff ^ (q.natDegree + 1) ≠ 0\nh... | rw [← degree_eq_natDegree hp0]; exact hp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Div | {
"line": 74,
"column": 6
} | {
"line": 74,
"column": 46
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np q : R[X]\nhp : 0 < p.degree\nhmp : p.Monic\nhq : q ≠ 0\nzn0 : 0 ≠ 1\nx✝ : p ^ (q.natDegree + 1) ∣ q\nr : R[X]\nhr : q = p ^ (q.natDegree + 1) * r\nhp0 : p ≠ 0\nhr0 : r ≠ 0\nhpn1 : p.leadingCoeff ^ (q.natDegree + 1) = 1\nhpn0' : p.leadingCoeff ^ (q.natDegree + 1) ≠ 0\nh... | rw [← degree_eq_natDegree hp0]; exact hp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Div | {
"line": 75,
"column": 4
} | {
"line": 75,
"column": 34
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np q : R[X]\nhp : 0 < p.degree\nhmp : p.Monic\nhq : q ≠ 0\nzn0 : 0 ≠ 1\nx✝ : p ^ (q.natDegree + 1) ∣ q\nr : R[X]\nhr : q = p ^ (q.natDegree + 1) * r\nhp0 : p ≠ 0\nhr0 : r ≠ 0\nhpn1 : p.leadingCoeff ^ (q.natDegree + 1) = 1\nhpn0' : p.leadingCoeff ^ (q.natDegree + 1) ≠ 0\nh... | have := congr_arg natDegree hr | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.