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 375
values | kind stringclasses 379
values |
|---|---|---|---|---|---|---|---|---|
Mathlib.RingTheory.Adjoin.FG | {
"line": 167,
"column": 2
} | {
"line": 167,
"column": 36
} | {
"line": 168,
"column": 2
} | [
{
"pp": "R : Type u\nA : Type v\ninst✝³ : CommSemiring R\ninst✝² : Semiring A\ninst✝¹ : Algebra R A\ninst✝ : IsNoetherian R A\nP : Subalgebra R A → Prop\nbase : P ⊥\nih : ∀ (S : Subalgebra R A) (x : A), P S → P (Algebra.adjoin R (insert x ↑S))\nt : Finset A\n⊢ P (Algebra.adjoin R ↑t)",
"ppTerm": "?m.49",
... | [
"case refine_1\nR : Type u\nA : Type v\ninst✝³ : CommSemiring R\ninst✝² : Semiring A\ninst✝¹ : Algebra R A\ninst✝ : IsNoetherian R A\nP : Subalgebra R A → Prop\nbase : P ⊥\nih : ∀ (S : Subalgebra R A) (x : A), P S → P (Algebra.adjoin R (insert x ↑S))\nt : Finset A\n⊢ P (Algebra.adjoin R ↑∅)",
"case refine_2\nR : ... | refine Finset.induction_on t ?_ ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.RingTheory.Adjoin.Tower | {
"line": 113,
"column": 4
} | {
"line": 114,
"column": 53
} | {
"line": 115,
"column": 4
} | [
{
"pp": "case inr.inl\nA : Type w\nB : Type u₁\nC : Type u_1\ninst✝⁶ : CommSemiring A\ninst✝⁵ : CommSemiring B\ninst✝⁴ : Semiring C\ninst✝³ : Algebra A B\ninst✝² : Algebra B C\ninst✝¹ : Algebra A C\ninst✝ : IsScalarTower A B C\nx : Finset C\nhx : Algebra.adjoin A ↑x = ⊤\ny : Finset C\nhy : span B ↑y = ⊤\nf : C ... | [
"case inr.inr\nA : Type w\nB : Type u₁\nC : Type u_1\ninst✝⁶ : CommSemiring A\ninst✝⁵ : CommSemiring B\ninst✝⁴ : Semiring C\ninst✝³ : Algebra A B\ninst✝² : Algebra B C\ninst✝¹ : Algebra A C\ninst✝ : IsScalarTower A B C\nx : Finset C\nhx : Algebra.adjoin A ↑x = ⊤\ny : Finset C\nhy : span B ↑y = ⊤\nf : C → C → B\nh✝ ... | · rw [mul_one]
exact subset_span (Set.mem_insert_of_mem _ hyi) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 597,
"column": 6
} | {
"line": 597,
"column": 17
} | {
"line": 598,
"column": 6
} | [
{
"pp": "case mem_or_mem'\nR : Type u\ninst✝ : CommRing R\nP : Ideal R\nh : P.IsPrime\nf g : R[X]\n⊢ (∀ (n : ℕ), (f * g).coeff n ∈ P) → (∀ (n : ℕ), f.coeff n ∈ P) ∨ ∀ (n : ℕ), g.coeff n ∈ P",
"ppTerm": "?mem_or_mem'",
"assigned": true,
"usedConstants": [
"Mathlib.Tactic.Push.not_forall_eq",
... | [
"case mem_or_mem'\nR : Type u\ninst✝ : CommRing R\nP : Ideal R\nh : P.IsPrime\nf g : R[X]\n⊢ ((∃ n, f.coeff n ∉ P) ∧ ∃ n, g.coeff n ∉ P) → ∃ n, (f * g).coeff n ∉ P"
] | contrapose! | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 616,
"column": 10
} | {
"line": 616,
"column": 56
} | {
"line": 617,
"column": 8
} | [
{
"pp": "case inl\nR : Type u\ninst✝ : CommRing R\nP : Ideal R\nh : P.IsPrime\nf g : R[X]\nhf : ∃ n, f.coeff n ∉ P\nhg : ∃ n, g.coeff n ∉ P\nm : ℕ := ⋯\nn : ℕ := ⋯\ni j : ℕ\nhij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n\nhi : i < m\n⊢ f.coeff (i, j).1 ∈ P",
"ppTerm": "?inl",
"assigned": true,
"usedConstan... | [] | exact Classical.not_not.1 (Nat.find_min hf hi) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 824,
"column": 12
} | {
"line": 828,
"column": 77
} | {
"line": 829,
"column": 10
} | [
{
"pp": "case h.inr.convert_2\nR : Type u\ninst✝ : CommRing R\ninst : IsNoetherianRing R\nI : Ideal R[X]\nM : Submodule R R := ⋯.min (Set.range I.leadingCoeffNth) ⋯\nhm : M ∈ Set.range I.leadingCoeffNth\nN : ℕ\nHN : I.leadingCoeffNth N = M\ns : Finset R[X]\nhs : Submodule.span R ↑s = I.degreeLE ↑N\nhm2 : ∀ (k :... | [] | by_cases hpq : p - q * Polynomial.X ^ (k - q.natDegree) = 0
· rw [hpq]
exact Ideal.zero_mem _
refine ih _ ?_ (I.sub_mem hp (I.mul_mem_right _ hq)) rfl
rwa [Polynomial.degree_eq_natDegree hpq, Nat.cast_lt, hn] at this | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 824,
"column": 12
} | {
"line": 828,
"column": 77
} | {
"line": 829,
"column": 10
} | [
{
"pp": "case h.inr.convert_2\nR : Type u\ninst✝ : CommRing R\ninst : IsNoetherianRing R\nI : Ideal R[X]\nM : Submodule R R := ⋯.min (Set.range I.leadingCoeffNth) ⋯\nhm : M ∈ Set.range I.leadingCoeffNth\nN : ℕ\nHN : I.leadingCoeffNth N = M\ns : Finset R[X]\nhs : Submodule.span R ↑s = I.degreeLE ↑N\nhm2 : ∀ (k :... | [] | by_cases hpq : p - q * Polynomial.X ^ (k - q.natDegree) = 0
· rw [hpq]
exact Ideal.zero_mem _
refine ih _ ?_ (I.sub_mem hp (I.mul_mem_right _ hq)) rfl
rwa [Polynomial.degree_eq_natDegree hpq, Nat.cast_lt, hn] at this | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Ideal.Quotient.Operations | {
"line": 135,
"column": 41
} | {
"line": 135,
"column": 65
} | {
"line": 135,
"column": 65
} | [
{
"pp": "R : Type u\ninst✝¹ : Ring R\nI : Ideal R\ninst✝ : I.IsTwoSided\nx✝ : R\n⊢ (Quotient.mk I) x✝ = 0 ↔ x✝ ∈ I",
"ppTerm": "?m.49",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Submodule.Quotient.instZeroQuotient",
"Semiring.toModule",
"congrArg",
"Ideal.Quotient... | [
"R : Type u\ninst✝¹ : Ring R\nI : Ideal R\ninst✝ : I.IsTwoSided\nx✝ : R\n⊢ x✝ ∈ I ↔ x✝ ∈ I"
] | Quotient.eq_zero_iff_mem | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.CharP.Basic | {
"line": 68,
"column": 15
} | {
"line": 68,
"column": 29
} | {
"line": 68,
"column": 30
} | [
{
"pp": "R : Type u_1\ninst✝¹ : AddGroupWithOne R\np : ℕ\ninst✝ : CharP R p\na b : ℤ\n⊢ ↑b = ↑a ↔ a ≡ b [ZMOD ↑p]",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast",
"Eq.mpr",
"AddGroupWithOne.toAddGroup",
"congrArg",
... | [
"R : Type u_1\ninst✝¹ : AddGroupWithOne R\np : ℕ\ninst✝ : CharP R p\na b : ℤ\n⊢ ↑b - ↑a = 0 ↔ a ≡ b [ZMOD ↑p]"
] | ← sub_eq_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Algebra.Subalgebra.Unitization | {
"line": 142,
"column": 6
} | {
"line": 143,
"column": 65
} | {
"line": 144,
"column": 6
} | [
{
"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... | [
"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 (Algebra.adjoin... | have := AlgHomClass.unitization_injective s h1
((Subalgebra.val _).comp algHom) fun _ ↦ by simp [algHom] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.CharP.Two | {
"line": 204,
"column": 15
} | {
"line": 204,
"column": 29
} | {
"line": 204,
"column": 30
} | [
{
"pp": "R : Type u_1\ninst✝¹ : Ring R\ninst✝ : Nontrivial R\nh : 1 = -1\n⊢ ringChar R = 2",
"ppTerm": "?m.32",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"AddGroupWithOne.toAddGroup",
"congrArg",
"sub_eq_zero",
"Add... | [
"R : Type u_1\ninst✝¹ : Ring R\ninst✝ : Nontrivial R\nh : 1 - -1 = 0\n⊢ ringChar R = 2"
] | ← sub_eq_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Prime.Basic | {
"line": 133,
"column": 6
} | {
"line": 133,
"column": 35
} | {
"line": 133,
"column": 36
} | [
{
"pp": "n m : ℕ\nh₀ : m ≠ 0\nh : m < n.minFac\n⊢ n.Coprime m",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.Coprime",
"Classical.not_not",
"congrArg",
"id",
"propext",
"Eq.symm",
"Eq",
"Not"
],
"usedFVars": [
... | [
"n m : ℕ\nh₀ : m ≠ 0\nh : m < n.minFac\n⊢ ¬¬n.Coprime m"
] | ← not_not (a := n.Coprime m), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Ideal.Quotient.Operations | {
"line": 573,
"column": 7
} | {
"line": 573,
"column": 28
} | {
"line": 573,
"column": 28
} | [
{
"pp": "R : Type u_5\nA : Type u_6\nB : Type u_7\nC : Type u_8\ninst✝⁶ : CommRing R\ninst✝⁵ : CommRing A\ninst✝⁴ : CommRing B\ninst✝³ : CommRing C\ninst✝² : Algebra R A\ninst✝¹ : Algebra R B\ninst✝ : Algebra R C\nf : A →ₐ[R] B\nhf : Surjective ⇑f\ng : A →ₐ[R] C\nH : ker f.toRingHom ≤ ker g.toRingHom\nx : A\n⊢ ... | [
"R : Type u_5\nA : Type u_6\nB : Type u_7\nC : Type u_8\ninst✝⁶ : CommRing R\ninst✝⁵ : CommRing A\ninst✝⁴ : CommRing B\ninst✝³ : CommRing C\ninst✝² : Algebra R A\ninst✝¹ : Algebra R B\ninst✝ : Algebra R C\nf : A →ₐ[R] B\nhf : Surjective ⇑f\ng : A →ₐ[R] C\nH : ker f.toRingHom ≤ ker g.toRingHom\nx : A\n⊢ (Quotient.li... | AlgEquiv.coe_toAlgHom | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Ideal.Quotient.Operations | {
"line": 662,
"column": 22
} | {
"line": 662,
"column": 46
} | {
"line": 662,
"column": 46
} | [
{
"pp": "R : Type u\ninst✝³ : Ring R\nS : Type v\ninst✝² : Ring S\nJ : Ideal R\nI : Ideal S\ninst✝¹ : I.IsTwoSided\ninst✝ : J.IsTwoSided\nf : R →+* S\nH : J ≤ comap f I\nh : comap f I ≤ J\nr : R\nha : (Quotient.mk I) (f r) = 0\n⊢ (Quotient.mk J) r = 0",
"ppTerm": "?m.98",
"assigned": true,
"usedCons... | [
"R : Type u\ninst✝³ : Ring R\nS : Type v\ninst✝² : Ring S\nJ : Ideal R\nI : Ideal S\ninst✝¹ : I.IsTwoSided\ninst✝ : J.IsTwoSided\nf : R →+* S\nH : J ≤ comap f I\nh : comap f I ≤ J\nr : R\nha : f r ∈ I\n⊢ (Quotient.mk J) r = 0"
] | Quotient.eq_zero_iff_mem | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Permutation | {
"line": 150,
"column": 2
} | {
"line": 150,
"column": 19
} | {
"line": 150,
"column": 20
} | [
{
"pp": "case cons\nα : Type u_1\nt : α\nts l' : List α\ny : α\nys : List α\nih :\n ∀ {l : List α},\n l' ∈ (permutationsAux2 t ts [] ys fun x ↦ l ++ x).snd ↔\n ∃ l₁ l₂, l₂ ≠ [] ∧ ys = l₁ ++ l₂ ∧ l' = l ++ l₁ ++ t :: l₂ ++ ts\nl : List α\n⊢ l' ∈ (permutationsAux2 t ts [] (y :: ys) fun x ↦ l ++ x).snd ↔\... | [
"case cons\nα : Type u_1\nt : α\nts l' : List α\ny : α\nys : List α\nih :\n ∀ {l : List α},\n l' ∈ (permutationsAux2 t ts [] ys fun x ↦ l ++ x).snd ↔\n ∃ l₁ l₂, l₂ ≠ [] ∧ ys = l₁ ++ l₂ ∧ l' = l ++ l₁ ++ t :: l₂ ++ ts\nl : List α\n⊢ l' ∈ (permutationsAux2 t ts [] (y :: ys) fun x ↦ l ++ x).snd ↔\n ∃ l₁ l₂... | | cons y ys ih => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Dynamics.PeriodicPts.Defs | {
"line": 169,
"column": 2
} | {
"line": 169,
"column": 83
} | {
"line": 171,
"column": 0
} | [
{
"pp": "α : Type u_1\nf : α → α\nx y : α\nn : ℕ\nhx : IsPeriodicPt f n x\nhy : IsPeriodicPt f n y\nhn : 0 < n\nh : f x = f y\n⊢ x = y",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Function.comp",
"id",
"Nat.iterate",
"Function.it... | [] | rw [← hx.eq, ← hy.eq, ← iterate_pred_comp_of_pos f hn, comp_apply, comp_apply, h] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Dynamics.PeriodicPts.Defs | {
"line": 169,
"column": 2
} | {
"line": 169,
"column": 83
} | {
"line": 171,
"column": 0
} | [
{
"pp": "α : Type u_1\nf : α → α\nx y : α\nn : ℕ\nhx : IsPeriodicPt f n x\nhy : IsPeriodicPt f n y\nhn : 0 < n\nh : f x = f y\n⊢ x = y",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Function.comp",
"id",
"Nat.iterate",
"Function.it... | [] | rw [← hx.eq, ← hy.eq, ← iterate_pred_comp_of_pos f hn, comp_apply, comp_apply, h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.PeriodicPts.Defs | {
"line": 169,
"column": 2
} | {
"line": 169,
"column": 83
} | {
"line": 171,
"column": 0
} | [
{
"pp": "α : Type u_1\nf : α → α\nx y : α\nn : ℕ\nhx : IsPeriodicPt f n x\nhy : IsPeriodicPt f n y\nhn : 0 < n\nh : f x = f y\n⊢ x = y",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Function.comp",
"id",
"Nat.iterate",
"Function.it... | [] | rw [← hx.eq, ← hy.eq, ← iterate_pred_comp_of_pos f hn, comp_apply, comp_apply, h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Permutation | {
"line": 244,
"column": 2
} | {
"line": 251,
"column": 30
} | {
"line": 253,
"column": 0
} | [
{
"pp": "α : Type u_1\nis is' ts : List α\n⊢ (is ++ ts).permutationsAux is' =\n map (fun x ↦ x ++ ts) (is.permutationsAux is') ++ ts.permutationsAux (is.reverse ++ is')",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"List.permutationsAux_nil",
"Eq.mpr",
"List.map_perm... | [] | induction is generalizing is' with | nil => simp | cons t is ih =>
simp only [foldr_permutationsAux2, ih, map_flatMap, cons_append, permutationsAux_cons, map_append,
reverse_cons, append_assoc]
congr 2
funext _
rw [map_permutationsAux2]
simp +singlePass only [← permutationsAux2_comp_append]
simp only [i... | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.List.Permutation | {
"line": 244,
"column": 2
} | {
"line": 251,
"column": 30
} | {
"line": 253,
"column": 0
} | [
{
"pp": "α : Type u_1\nis is' ts : List α\n⊢ (is ++ ts).permutationsAux is' =\n map (fun x ↦ x ++ ts) (is.permutationsAux is') ++ ts.permutationsAux (is.reverse ++ is')",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"List.permutationsAux_nil",
"Eq.mpr",
"List.map_perm... | [] | induction is generalizing is' with | nil => simp | cons t is ih =>
simp only [foldr_permutationsAux2, ih, map_flatMap, cons_append, permutationsAux_cons, map_append,
reverse_cons, append_assoc]
congr 2
funext _
rw [map_permutationsAux2]
simp +singlePass only [← permutationsAux2_comp_append]
simp only [i... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Permutation | {
"line": 244,
"column": 2
} | {
"line": 251,
"column": 30
} | {
"line": 253,
"column": 0
} | [
{
"pp": "α : Type u_1\nis is' ts : List α\n⊢ (is ++ ts).permutationsAux is' =\n map (fun x ↦ x ++ ts) (is.permutationsAux is') ++ ts.permutationsAux (is.reverse ++ is')",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"List.permutationsAux_nil",
"Eq.mpr",
"List.map_perm... | [] | induction is generalizing is' with | nil => simp | cons t is ih =>
simp only [foldr_permutationsAux2, ih, map_flatMap, cons_append, permutationsAux_cons, map_append,
reverse_cons, append_assoc]
congr 2
funext _
rw [map_permutationsAux2]
simp +singlePass only [← permutationsAux2_comp_append]
simp only [i... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Permutation | {
"line": 265,
"column": 4
} | {
"line": 270,
"column": 89
} | {
"line": 272,
"column": 0
} | [
{
"pp": "case inr\nα : Type u_1\nt : α\nts is : List α\nIH1 : ∀ (l : List α), l ∈ ts.permutationsAux (t :: is) → l ~ ts ++ t :: is\nIH2 : ∀ (l : List α), l ∈ is.permutationsAux [] → l ~ is ++ []\nl₁ l₂ : List α\nm : l₁ ++ l₂ ∈ is :: is.permutationsAux []\nleft✝ : l₂ ≠ []\n⊢ l₁ ++ t :: l₂ ++ ts ~ t :: ts ++ is",... | [] | have p : l₁ ++ l₂ ~ is := by
simp only [mem_cons] at m
rcases m with e | m
· simp [e]
exact is.append_nil ▸ IH2 _ m
exact ((perm_middle.trans (p.cons _)).append_right _).trans (perm_append_comm.cons _) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Permutation | {
"line": 265,
"column": 4
} | {
"line": 270,
"column": 89
} | {
"line": 272,
"column": 0
} | [
{
"pp": "case inr\nα : Type u_1\nt : α\nts is : List α\nIH1 : ∀ (l : List α), l ∈ ts.permutationsAux (t :: is) → l ~ ts ++ t :: is\nIH2 : ∀ (l : List α), l ∈ is.permutationsAux [] → l ~ is ++ []\nl₁ l₂ : List α\nm : l₁ ++ l₂ ∈ is :: is.permutationsAux []\nleft✝ : l₂ ≠ []\n⊢ l₁ ++ t :: l₂ ++ ts ~ t :: ts ++ is",... | [] | have p : l₁ ++ l₂ ~ is := by
simp only [mem_cons] at m
rcases m with e | m
· simp [e]
exact is.append_nil ▸ IH2 _ m
exact ((perm_middle.trans (p.cons _)).append_right _).trans (perm_append_comm.cons _) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Cycle | {
"line": 98,
"column": 2
} | {
"line": 98,
"column": 19
} | {
"line": 98,
"column": 20
} | [
{
"pp": "case cons\nα : Type u_1\ninst✝ : DecidableEq α\nx d : α\nxs' : List α\nhd : d ∈ xs'\ny : α\nys : List α\nih : (∀ x ∈ ys, x ∈ xs') → ys.nextOr x d ∈ xs'\nhxs' : ∀ x ∈ y :: ys, x ∈ xs'\n⊢ (y :: ys).nextOr x d ∈ xs'",
"ppTerm": "?cons",
"assigned": true,
"usedConstants": [],
"usedFVars": [... | [
"case cons\nα : Type u_1\ninst✝ : DecidableEq α\nx d : α\nxs' : List α\nhd : d ∈ xs'\ny : α\nys : List α\nih : (∀ x ∈ ys, x ∈ xs') → ys.nextOr x d ∈ xs'\nhxs' : ∀ x ∈ y :: ys, x ∈ xs'\n⊢ (y :: ys).nextOr x d ∈ xs'"
] | | cons y ys ih => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.GroupTheory.GroupAction.Basic | {
"line": 359,
"column": 6
} | {
"line": 359,
"column": 20
} | {
"line": 359,
"column": 21
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝⁴ : Ring R\ninst✝³ : IsDomain R\ninst✝² : AddCommGroup M\ninst✝¹ : Module R M\ninst✝ : IsTorsionFree R M\nx : M\nhx : x ≠ 0\ng : Rˣ\nhg : ↑g • x = x\n⊢ ↑g = ↑1",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
... | [
"R : Type u_1\nM : Type u_2\ninst✝⁴ : Ring R\ninst✝³ : IsDomain R\ninst✝² : AddCommGroup M\ninst✝¹ : Module R M\ninst✝ : IsTorsionFree R M\nx : M\nhx : x ≠ 0\ng : Rˣ\nhg : ↑g • x = x\n⊢ ↑g - ↑1 = 0"
] | ← sub_eq_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Prime.Pow | {
"line": 23,
"column": 2
} | {
"line": 23,
"column": 37
} | {
"line": 24,
"column": 2
} | [
{
"pp": "n k : ℕ\nhk : k ≠ 0\n⊢ (n ^ k).minFac = n.minFac",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Nat.instMonoid",
"Nat.minFac",
"Ne",
"instOfNatNat",
"NPow.toPow",
"Or.casesOn",
"HPow.hPow",
"Nat",
"Eq.ndrec",
"eq_or_ne",... | [
"case inl\nk : ℕ\nhk : k ≠ 0\n⊢ (1 ^ k).minFac = minFac 1",
"case inr\nn k : ℕ\nhk : k ≠ 0\nhn : n ≠ 1\n⊢ (n ^ k).minFac = n.minFac"
] | rcases eq_or_ne n 1 with (rfl | hn) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.Nat.Factors | {
"line": 170,
"column": 2
} | {
"line": 179,
"column": 48
} | {
"line": 181,
"column": 0
} | [
{
"pp": "n : ℕ\nl : List ℕ\nh₁ : l.prod = n\nh₂ : ∀ (p : ℕ), p ∈ l → Prime p\n⊢ l ~ n.primeFactorsList",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"False",
"IsDomain.to_noZeroDivisors",
"Nat.Prime",
"Nat.prime_of_mem_primeFa... | [] | refine perm_of_prod_eq_prod ?_ ?_ ?_
· rw [h₁]
refine (prod_primeFactorsList ?_).symm
rintro rfl
rw [prod_eq_zero_iff] at h₁
exact Prime.ne_zero (h₂ 0 h₁) rfl
· simp_rw [← prime_iff]
exact h₂
· simp_rw [← prime_iff]
exact fun p => prime_of_mem_primeFactorsList | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factors | {
"line": 170,
"column": 2
} | {
"line": 179,
"column": 48
} | {
"line": 181,
"column": 0
} | [
{
"pp": "n : ℕ\nl : List ℕ\nh₁ : l.prod = n\nh₂ : ∀ (p : ℕ), p ∈ l → Prime p\n⊢ l ~ n.primeFactorsList",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"False",
"IsDomain.to_noZeroDivisors",
"Nat.Prime",
"Nat.prime_of_mem_primeFa... | [] | refine perm_of_prod_eq_prod ?_ ?_ ?_
· rw [h₁]
refine (prod_primeFactorsList ?_).symm
rintro rfl
rw [prod_eq_zero_iff] at h₁
exact Prime.ne_zero (h₂ 0 h₁) rfl
· simp_rw [← prime_iff]
exact h₂
· simp_rw [← prime_iff]
exact fun p => prime_of_mem_primeFactorsList | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.PrimeFin | {
"line": 83,
"column": 4
} | {
"line": 83,
"column": 15
} | {
"line": 84,
"column": 4
} | [
{
"pp": "case mp\nn : ℕ\n⊢ n.primeFactors = ∅ → n = 0 ∨ n = 1",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Finset",
"id",
"Ne",
"instOfNatNat",
"Finset.instEmptyCollection",
"not_or._simp_2",
"Mathlib.Tactic.Contrapose.contrapose₁... | [
"case mp\nn : ℕ\n⊢ n ≠ 0 ∧ n ≠ 1 → n.primeFactors.Nonempty"
] | contrapose! | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.Data.Nat.PrimeFin | {
"line": 91,
"column": 2
} | {
"line": 91,
"column": 13
} | {
"line": 92,
"column": 2
} | [
{
"pp": "n : ℕ\n⊢ n.primeFactors.Nonempty ↔ 1 < n",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Mathlib.Tactic.Contrapose.contrapose_iff₁",
"congrArg",
"Finset",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"instOfNatNat",
... | [
"n : ℕ\n⊢ n.primeFactors = ∅ ↔ n ≤ 1"
] | contrapose! | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.Data.Nat.Factors | {
"line": 243,
"column": 12
} | {
"line": 243,
"column": 42
} | {
"line": 243,
"column": 42
} | [
{
"pp": "case h\nb : ℕ\nhb : b > 0\na : ℕ\nha : a + 1 + 1 ≠ 0\nh : (a + 1 + 1).primeFactorsList <+~ b.primeFactorsList\n⊢ b = (a + 1 + 1) * (b.primeFactorsList.diff a.succ.succ.primeFactorsList).prod",
"ppTerm": "?h",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Nat... | [
"case h\nb : ℕ\nhb : b > 0\na : ℕ\nha : a + 1 + 1 ≠ 0\nh : (a + 1 + 1).primeFactorsList <+~ b.primeFactorsList\n⊢ b = (a + 1 + 1).primeFactorsList.prod * (b.primeFactorsList.diff a.succ.succ.primeFactorsList).prod"
] | ← Nat.prod_primeFactorsList ha | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Index | {
"line": 96,
"column": 51
} | {
"line": 97,
"column": 76
} | {
"line": 99,
"column": 0
} | [
{
"pp": "G : Type u_1\nG' : Type u_2\ninst✝¹ : Group G\ninst✝ : Group G'\nf : G →* G'\nH K : Subgroup G\nhf : Injective ⇑f\n⊢ (map f H).relIndex (map f K) = H.relIndex K",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Subgroup.map",
"congrArg",
"id",
... | [] | by
rw [← Subgroup.relIndex_comap, Subgroup.comap_map_eq_self_of_injective hf] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Index | {
"line": 426,
"column": 2
} | {
"line": 426,
"column": 52
} | {
"line": 427,
"column": 2
} | [
{
"pp": "case pos\nG : Type u_1\ninst✝ : Group G\nH K L : Subgroup G\nh : H.relIndex L = 0\n⊢ (H ⊓ K).relIndex L ≤ H.relIndex L * K.relIndex L",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"HMul... | [
"case neg\nG : Type u_1\ninst✝ : Group G\nH K L : Subgroup G\nh : ¬H.relIndex L = 0\n⊢ (H ⊓ K).relIndex L ≤ H.relIndex L * K.relIndex L"
] | · simp [relIndex_eq_zero_of_le_left inf_le_left h] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.ZMod.Basic | {
"line": 312,
"column": 35
} | {
"line": 312,
"column": 49
} | {
"line": 312,
"column": 50
} | [
{
"pp": "case succ\nR : Type u_1\ninst✝¹ : Ring R\nm : ℕ\ninst✝ : CharP R m\nn✝ : ℕ\nh : m ∣ n✝ + 1\na b : ZMod (n✝ + 1)\n⊢ ↑(↑a + ↑b) = ↑((↑a + ↑b) % (n✝ + 1))",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"AddGroupWithOne.toAd... | [
"case succ\nR : Type u_1\ninst✝¹ : Ring R\nm : ℕ\ninst✝ : CharP R m\nn✝ : ℕ\nh : m ∣ n✝ + 1\na b : ZMod (n✝ + 1)\n⊢ ↑(↑a + ↑b) - ↑((↑a + ↑b) % (n✝ + 1)) = 0"
] | ← sub_eq_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.ZMod.Basic | {
"line": 323,
"column": 35
} | {
"line": 323,
"column": 49
} | {
"line": 323,
"column": 50
} | [
{
"pp": "case succ\nR : Type u_1\ninst✝¹ : Ring R\nm : ℕ\ninst✝ : CharP R m\nn✝ : ℕ\nh : m ∣ n✝ + 1\na b : ZMod (n✝ + 1)\n⊢ ↑(↑a * ↑b) = ↑(↑a * ↑b % (n✝ + 1))",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NonAssocSemiring.toAdd... | [
"case succ\nR : Type u_1\ninst✝¹ : Ring R\nm : ℕ\ninst✝ : CharP R m\nn✝ : ℕ\nh : m ∣ n✝ + 1\na b : ZMod (n✝ + 1)\n⊢ ↑(↑a * ↑b) - ↑(↑a * ↑b % (n✝ + 1)) = 0"
] | ← sub_eq_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Index | {
"line": 571,
"column": 67
} | {
"line": 571,
"column": 78
} | {
"line": 571,
"column": 79
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\nh : H.index ≠ 0\na : G\nn₁ n₂ : ℕ\nhlt : n₁ < n₂\nhle : n₂ ≤ H.index\nhe : (a ^ ↑n₁)⁻¹ * a ^ ↑n₂ ∈ H\n⊢ a ^ (n₂ - n₁) ∈ H",
"ppTerm": "?m.135",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
... | [
"G : Type u_1\ninst✝ : Group G\nH : Subgroup G\nh : H.index ≠ 0\na : G\nn₁ n₂ : ℕ\nhlt : n₁ < n₂\nhle : n₂ ≤ H.index\nhe : a ^ (-↑n₁) * a ^ ↑n₂ ∈ H\n⊢ a ^ (n₂ - n₁) ∈ H"
] | ← zpow_neg, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Index | {
"line": 596,
"column": 53
} | {
"line": 599,
"column": 45
} | {
"line": 601,
"column": 0
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH K : Subgroup G\nh : H.relIndex K ≠ 0\na : G\nha : a ∈ K\n⊢ ∃ n, 0 < n ∧ n ≤ H.relIndex K ∧ a ^ n ∈ H ⊓ K",
"ppTerm": "?m.35",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Subgroup.subgroupOf",
"Subgroup.instSubgroupClass",
"and_tru... | [] | by
rcases exists_pow_mem_of_index_ne_zero h ⟨a, ha⟩ with ⟨n, hlt, hle, he⟩
refine ⟨n, hlt, hle, ?_⟩
simpa [pow_mem ha, mem_subgroupOf] using he | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.NumberTheory.Divisors | {
"line": 258,
"column": 2
} | {
"line": 258,
"column": 13
} | {
"line": 259,
"column": 2
} | [
{
"pp": "n : ℕ\n⊢ n.divisors = ∅ ↔ n = 0",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Mathlib.Tactic.Contrapose.contrapose_iff₁",
"congrArg",
"Finset",
"id",
"Ne",
"instOfNatNat",
"Finset.instEmptyCollection",
"Nat.divisors... | [
"n : ℕ\n⊢ n.divisors.Nonempty ↔ n ≠ 0"
] | contrapose! | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.NumberTheory.Divisors | {
"line": 315,
"column": 2
} | {
"line": 315,
"column": 13
} | {
"line": 316,
"column": 2
} | [
{
"pp": "n : ℕ\n⊢ n.properDivisors = ∅ ↔ n ≤ 1",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Mathlib.Tactic.Contrapose.contrapose_iff₁",
"congrArg",
"Finset",
"PartialOrder.toPreorder",
"id",
"instOfNatNat",
... | [
"n : ℕ\n⊢ n.properDivisors.Nonempty ↔ 1 < n"
] | contrapose! | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.Algebra.Order.Ring.GeomSum | {
"line": 98,
"column": 2
} | {
"line": 103,
"column": 36
} | {
"line": 105,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\nn : ℕ\nx : R\nhx : 0 < x + 1\nhn : n ≠ 0\n⊢ 0 < ∑ i ∈ range n, x ^ i",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"False",
"Nat.instMulZeroClass",
"Preo... | [] | obtain _ | _ | n := n
· cases hn rfl
· simp only [zero_add, range_one, sum_singleton, pow_zero, zero_lt_one]
obtain hx' | hx' := lt_or_ge x 0
· exact (geom_sum_pos_and_lt_one hx' hx n.one_lt_succ_succ).1
· exact geom_sum_pos hx' (by simp) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Ring.GeomSum | {
"line": 98,
"column": 2
} | {
"line": 103,
"column": 36
} | {
"line": 105,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\nn : ℕ\nx : R\nhx : 0 < x + 1\nhn : n ≠ 0\n⊢ 0 < ∑ i ∈ range n, x ^ i",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"False",
"Nat.instMulZeroClass",
"Preo... | [] | obtain _ | _ | n := n
· cases hn rfl
· simp only [zero_add, range_one, sum_singleton, pow_zero, zero_lt_one]
obtain hx' | hx' := lt_or_ge x 0
· exact (geom_sum_pos_and_lt_one hx' hx n.one_lt_succ_succ).1
· exact geom_sum_pos hx' (by simp) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Divisors | {
"line": 349,
"column": 2
} | {
"line": 350,
"column": 36
} | {
"line": 351,
"column": 2
} | [
{
"pp": "n : ℕ\n⊢ map (Equiv.prodComm ℕ ℕ).toEmbedding n.divisorsAntidiagonal = n.divisorsAntidiagonal",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Set.image_swap_eq_preimage_swap",
"Equiv.instEquivLike",
"Nat.divisorsAntidiagonal",
"Equiv.coe_toE... | [
"n : ℕ\n⊢ Prod.swap ⁻¹' ↑n.divisorsAntidiagonal = ↑n.divisorsAntidiagonal"
] | rw [← coe_inj, coe_map, Equiv.coe_toEmbedding, Equiv.coe_prodComm,
Set.image_swap_eq_preimage_swap] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.ZMod.Basic | {
"line": 821,
"column": 90
} | {
"line": 822,
"column": 59
} | {
"line": 824,
"column": 0
} | [
{
"pp": "n p : ℕ\nhp : Nat.Prime p\n⊢ IsUnit ↑p ↔ ¬p ∣ n",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"ZMod.isUnit_iff_coprime",
"Eq.mpr",
"Nat.Coprime",
"Dvd.dvd",
"ZMod.commRing",
"congrArg",
"CommSemiring.toSemiring",
"Iff.rfl",
"A... | [] | by
rw [isUnit_iff_coprime, Nat.Prime.coprime_iff_not_dvd hp] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.NumberTheory.Divisors | {
"line": 650,
"column": 2
} | {
"line": 650,
"column": 13
} | {
"line": 651,
"column": 2
} | [
{
"pp": "z : ℤ\n⊢ z.divisors = ∅ ↔ z = 0",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"Int.divisors",
"Eq.mpr",
"Mathlib.Tactic.Contrapose.contrapose_iff₁",
"congrArg",
"Finset",
"id",
"Ne",
"Int",
"Finset.instEmptyCollection",
... | [
"z : ℤ\n⊢ z.divisors.Nonempty ↔ z ≠ 0"
] | contrapose! | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.Data.ZMod.Basic | {
"line": 1014,
"column": 4
} | {
"line": 1014,
"column": 20
} | {
"line": 1015,
"column": 4
} | [
{
"pp": "case pos\nm : ℕ\ninst✝¹ : NeZero (m + 1)\na : ZMod (m + 1)\nn : ℕ\ninst✝ : NeZero (n + 1)\nh : m < n + 1\n⊢ a.val < m + 1",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"OfNat.ofNat"... | [
"case pos\nm : ℕ\ninst✝¹ : NeZero (m + 1)\na : ZMod (m + 1)\nn : ℕ\ninst✝ : NeZero (n + 1)\nh : m < n + 1\n⊢ a.val < n + 1"
] | · apply a.val_lt | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Nat.Digits.Defs | {
"line": 132,
"column": 2
} | {
"line": 132,
"column": 16
} | {
"line": 133,
"column": 2
} | [
{
"pp": "case succ\nx b : ℕ\nh : 1 < b + 2\nhxb : x < b + 2\nn✝ : ℕ\nhxy : x ≠ 0 ∨ n✝ + 1 ≠ 0\n⊢ (b + 2).digits (x + (b + 2) * (n✝ + 1)) = x :: (b + 2).digits (n✝ + 1)",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"id",
"instMulNat",
"instOfNatNat",
... | [
"case succ\nx b : ℕ\nh : 1 < b + 2\nhxb : x < b + 2\nn✝ : ℕ\nhxy : x ≠ 0 ∨ n✝ + 1 ≠ 0\n⊢ (b + 2).digitsAux ⋯ (x + (b + 2) * (n✝ + 1)) = x :: (b + 2).digitsAux ⋯ (n✝ + 1)"
] | dsimp [digits] | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.Data.ZMod.Basic | {
"line": 1149,
"column": 30
} | {
"line": 1156,
"column": 48
} | {
"line": 1156,
"column": 48
} | [
{
"pp": "n : ℕ\nR : Type u_1\nA : Type u_2\ninst✝ : AddGroup A\n⊢ ∀ (x : ℤ →+ A), x ↑n = 0 ↔ (Int.castAddHom (ZMod n)).ker ≤ x.ker",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"instHSMul",
"AddMonoidHom.map_zsmul",
... | [] | by
intro f
rw [ker_intCastAddHom]
constructor
· rintro hf _ ⟨x, rfl⟩
simp only [f.map_zsmul, zsmul_zero, f.mem_ker, hf]
· intro h
exact h (AddSubgroup.mem_zmultiples _) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.ZMod.Basic | {
"line": 1270,
"column": 2
} | {
"line": 1271,
"column": 54
} | {
"line": 1273,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Group α\nn : ℕ\na : α\nhn : (Nat.card α).Coprime n\n⊢ (a ^ (↑n)⁻¹.val) ^ n = a",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.Coprime.symm",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"ZMod.instInv",
... | [] | rw [← pow_mul', ← pow_mod_natCard, ← ZMod.val_natCast, Nat.cast_mul, ZMod.mul_val_inv hn.symm,
ZMod.val_one_eq_one_mod, pow_mod_natCard, pow_one] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.ZMod.Basic | {
"line": 1299,
"column": 16
} | {
"line": 1299,
"column": 65
} | {
"line": 1300,
"column": 2
} | [
{
"pp": "N : ℕ\ninst✝ : NeZero N\nn : ℕ\n⊢ (fun p ↦ p.1.val + N * p.2) ((fun n ↦ (↑n, n / N)) n) = n",
"ppTerm": "?m.32",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"ZMod.commRing",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
... | [] | by simpa only [val_natCast] using mod_add_div n N | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Digits.Defs | {
"line": 239,
"column": 8
} | {
"line": 239,
"column": 33
} | {
"line": 240,
"column": 8
} | [
{
"pp": "case neg\nb : ℕ\nh : 1 < b\nd : ℕ\nL : List ℕ\nih : (∀ l ∈ L, l < b) → (∀ (h : L ≠ []), L.getLast h ≠ 0) → b.digits (ofDigits b L) = L\nw₁ : ∀ l ∈ d :: L, l < b\nh' : ¬L = []\nw₂ : ofDigits b L = 0\n⊢ (d :: L).getLast ⋯ ∈ L",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Li... | [
"case neg\nb : ℕ\nh : 1 < b\nd : ℕ\nL : List ℕ\nih : (∀ l ∈ L, l < b) → (∀ (h : L ≠ []), L.getLast h ≠ 0) → b.digits (ofDigits b L) = L\nw₁ : ∀ l ∈ d :: L, l < b\nh' : ¬L = []\nw₂ : ofDigits b L = 0\n⊢ L.getLast h' ∈ L"
] | rw [List.getLast_cons h'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 78,
"column": 2
} | {
"line": 78,
"column": 13
} | {
"line": 79,
"column": 2
} | [
{
"pp": "b k : ℕ\nhb : 1 < b\nn : ℕ\n⊢ k < (b.digits n).length ↔ b ^ k ≤ n",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Mathlib.Tactic.Contrapose.contrapose_iff₁",
"congrArg",
"Nat.instMonoid",
"PartialOrder.toPreorder",
... | [
"b k : ℕ\nhb : 1 < b\nn : ℕ\n⊢ (b.digits n).length ≤ k ↔ n < b ^ k"
] | contrapose! | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.RingTheory.Multiplicity | {
"line": 98,
"column": 4
} | {
"line": 98,
"column": 60
} | {
"line": 100,
"column": 0
} | [
{
"pp": "case mpr\nα : Type u_1\ninst✝ : Monoid α\na b : α\nn : ℕ\nh : n ≠ 1\nh₂ : multiplicity a b = n\n⊢ emultiplicity a b = ↑n",
"ppTerm": "?mpr",
"assigned": true,
"usedConstants": [
"False",
"eq_false",
"congrArg",
"_private.Mathlib.RingTheory.Multiplicity.0.emultiplicit... | [] | simpa [multiplicity, WithTop.untopD_eq_iff, h] using! h₂ | Lean.Elab.Tactic.Simpa.evalSimpaUsingBang | Lean.Parser.Tactic.simpaUsingBang |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 263,
"column": 6
} | {
"line": 263,
"column": 48
} | {
"line": 264,
"column": 6
} | [
{
"pp": "case pos.succ\nb : ℕ\nh : b ≠ 1\nhb : 1 < b\nn : ℕ\n⊢ (b.digits (n + 1)).head! = (n + 1) % b",
"ppTerm": "?pos.succ✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Nat.ofDigits",
"List.head!",
"instInhabitedNat",
"id",
"Nat.instMod",
... | [
"case pos.succ\nb : ℕ\nh : b ≠ 1\nhb : 1 < b\nn : ℕ\n⊢ (b.digits (n + 1)).head! = ofDigits b (b.digits (n + 1)) % b"
] | nth_rw 2 [← Nat.ofDigits_digits b (n + 1)] | Mathlib.Tactic._aux_Mathlib_Tactic_NthRewrite___macroRules_Mathlib_Tactic_tacticNth_rw______1 | Mathlib.Tactic.tacticNth_rw_____ |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 300,
"column": 6
} | {
"line": 300,
"column": 18
} | {
"line": 300,
"column": 18
} | [
{
"pp": "b b' : ℕ\nc : ℤ\nh : ↑b' ≡ c [ZMOD ↑b]\nn : ℕ\n⊢ ↑(ofDigits b' (b'.digits n)) ≡ ofDigits c (b'.digits n) [ZMOD ↑b]",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"congrArg",
"Nat.ofDigits",
"id",
... | [
"b b' : ℕ\nc : ℤ\nh : ↑b' ≡ c [ZMOD ↑b]\nn : ℕ\n⊢ ofDigits (↑b') (b'.digits n) ≡ ofDigits c (b'.digits n) [ZMOD ↑b]"
] | coe_ofDigits | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Multiplicity | {
"line": 348,
"column": 2
} | {
"line": 348,
"column": 98
} | {
"line": 349,
"column": 2
} | [
{
"pp": "case mp\nα : Type u_1\nβ : Type u_2\ninst✝¹ : Monoid α\ninst✝ : Monoid β\na b : α\nc d : β\n⊢ emultiplicity a b ≤ emultiplicity c d → ∀ (n : ℕ), a ^ n ∣ b → c ^ n ∣ d",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Dvd.dvd",
"ENat.instNatCast",
"semigroupDvd",
... | [
"case mpr\nα : Type u_1\nβ : Type u_2\ninst✝¹ : Monoid α\ninst✝ : Monoid β\na b : α\nc d : β\n⊢ (∀ (n : ℕ), a ^ n ∣ b → c ^ n ∣ d) → emultiplicity a b ≤ emultiplicity c d"
] | · exact fun h n hab ↦ pow_dvd_of_le_emultiplicity (le_trans (le_emultiplicity_of_pow_dvd hab) h) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.GroupTheory.OrderOfElement | {
"line": 81,
"column": 2
} | {
"line": 86,
"column": 54
} | {
"line": 88,
"column": 0
} | [
{
"pp": "G : Type u_6\ninst✝ : DivisionMonoid G\nx : G\n⊢ IsOfFinOrder x ↔ ∃ n, n ≠ 0 ∧ x ^ n = 1",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"zpow_natCast",
"Iff.mpr",
"Eq.mpr",
"MulOne.toOne",
"InvOneClass.toOne",
"inv_eq_one",
"DivInvOneMono... | [] | rw [isOfFinOrder_iff_pow_eq_one]
refine ⟨fun ⟨n, hn, hn'⟩ ↦ ⟨n, Int.natCast_ne_zero_iff_pos.mpr hn, zpow_natCast x n ▸ hn'⟩,
fun ⟨n, hn, hn'⟩ ↦ ⟨n.natAbs, Int.natAbs_pos.mpr hn, ?_⟩⟩
rcases (Int.natAbs_eq_iff (a := n)).mp rfl with h | h
· rwa [h, zpow_natCast] at hn'
· rwa [h, zpow_neg, inv_eq_one, zpow_nat... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.OrderOfElement | {
"line": 81,
"column": 2
} | {
"line": 86,
"column": 54
} | {
"line": 88,
"column": 0
} | [
{
"pp": "G : Type u_6\ninst✝ : DivisionMonoid G\nx : G\n⊢ IsOfFinOrder x ↔ ∃ n, n ≠ 0 ∧ x ^ n = 1",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"zpow_natCast",
"Iff.mpr",
"Eq.mpr",
"MulOne.toOne",
"InvOneClass.toOne",
"inv_eq_one",
"DivInvOneMono... | [] | rw [isOfFinOrder_iff_pow_eq_one]
refine ⟨fun ⟨n, hn, hn'⟩ ↦ ⟨n, Int.natCast_ne_zero_iff_pos.mpr hn, zpow_natCast x n ▸ hn'⟩,
fun ⟨n, hn, hn'⟩ ↦ ⟨n.natAbs, Int.natAbs_pos.mpr hn, ?_⟩⟩
rcases (Int.natAbs_eq_iff (a := n)).mp rfl with h | h
· rwa [h, zpow_natCast] at hn'
· rwa [h, zpow_neg, inv_eq_one, zpow_nat... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 87,
"column": 2
} | {
"line": 87,
"column": 86
} | {
"line": 89,
"column": 0
} | [
{
"pp": "n p : ℕ\nhp : Prime p\nhn : n ≠ 0\nh : p ∣ n\n⊢ 0 < n.factorization p",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Nat.mem_primeFactorsList_iff_dvd",
"Eq.mpr",
"Nat.instMulZeroClass",
"Dvd.dvd",
"List.count_pos_iff",
... | [] | rwa [← primeFactorsList_count_eq, count_pos_iff, mem_primeFactorsList_iff_dvd hn hp] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 87,
"column": 2
} | {
"line": 87,
"column": 86
} | {
"line": 89,
"column": 0
} | [
{
"pp": "n p : ℕ\nhp : Prime p\nhn : n ≠ 0\nh : p ∣ n\n⊢ 0 < n.factorization p",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Nat.mem_primeFactorsList_iff_dvd",
"Eq.mpr",
"Nat.instMulZeroClass",
"Dvd.dvd",
"List.count_pos_iff",
... | [] | rwa [← primeFactorsList_count_eq, count_pos_iff, mem_primeFactorsList_iff_dvd hn hp] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 87,
"column": 2
} | {
"line": 87,
"column": 86
} | {
"line": 89,
"column": 0
} | [
{
"pp": "n p : ℕ\nhp : Prime p\nhn : n ≠ 0\nh : p ∣ n\n⊢ 0 < n.factorization p",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Nat.mem_primeFactorsList_iff_dvd",
"Eq.mpr",
"Nat.instMulZeroClass",
"Dvd.dvd",
"List.count_pos_iff",
... | [] | rwa [← primeFactorsList_count_eq, count_pos_iff, mem_primeFactorsList_iff_dvd hn hp] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 480,
"column": 2
} | {
"line": 480,
"column": 52
} | {
"line": 481,
"column": 2
} | [
{
"pp": "b : ℕ\nhb : 1 < b\nl d : ℕ\nhd : d < b\nL : List ℕ\nhL : L ∈ fixedLengthDigits hb l\n⊢ d :: L ∈ fixedLengthDigits hb (l + 1)",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Finset",
"Membership.mem",
"instOfNatNat",
"List.cons",
"Lis... | [
"case refine_1\nb : ℕ\nhb : 1 < b\nl d : ℕ\nhd : d < b\nL : List ℕ\nhL : L ∈ fixedLengthDigits hb l\n⊢ (d :: L).length = l + 1",
"case refine_2\nb : ℕ\nhb : 1 < b\nl d : ℕ\nhd : d < b\nL : List ℕ\nhL : L ∈ fixedLengthDigits hb l\n⊢ ∀ x ∈ d :: L, x < b"
] | refine (mem_fixedLengthDigits_iff hb).mpr ⟨?_, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 508,
"column": 4
} | {
"line": 508,
"column": 54
} | {
"line": 509,
"column": 4
} | [
{
"pp": "case refine_1\nb : ℕ\nhb : 1 < b\nl : ℕ\nL : List ℕ\nhL : L ∈ fixedLengthDigits hb (l + 1)\nhL₁ : L.length = l + 1\nhL₂ : ∀ x ∈ L, x < b\nhL₃ : L ≠ []\n⊢ L.tail ∈ fixedLengthDigits hb l",
"ppTerm": "?refine_1",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Finset",
"Mem... | [
"case refine_1.refine_1\nb : ℕ\nhb : 1 < b\nl : ℕ\nL : List ℕ\nhL : L ∈ fixedLengthDigits hb (l + 1)\nhL₁ : L.length = l + 1\nhL₂ : ∀ x ∈ L, x < b\nhL₃ : L ≠ []\n⊢ L.tail.length = l",
"case refine_1.refine_2\nb : ℕ\nhb : 1 < b\nl : ℕ\nL : List ℕ\nhL : L ∈ fixedLengthDigits hb (l + 1)\nhL₁ : L.length = l + 1\nhL₂ ... | refine (mem_fixedLengthDigits_iff hb).mpr ⟨?_, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 511,
"column": 4
} | {
"line": 512,
"column": 55
} | {
"line": 514,
"column": 0
} | [
{
"pp": "case refine_2\nb : ℕ\nhb : 1 < b\nl : ℕ\nL : List ℕ\n⊢ (∃ a < b, ∃ a_1 ∈ fixedLengthDigits hb l, a :: a_1 = L) → L ∈ fixedLengthDigits hb (l + 1)",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"Finset",
"Membership.mem",
"Exists",
"instOfNatNat",
... | [] | rintro ⟨d, hd₁, T, hT, rfl⟩
exact cons_mem_fixedLengthDigits_succ hb l d hd₁ hT | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 511,
"column": 4
} | {
"line": 512,
"column": 55
} | {
"line": 514,
"column": 0
} | [
{
"pp": "case refine_2\nb : ℕ\nhb : 1 < b\nl : ℕ\nL : List ℕ\n⊢ (∃ a < b, ∃ a_1 ∈ fixedLengthDigits hb l, a :: a_1 = L) → L ∈ fixedLengthDigits hb (l + 1)",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"Finset",
"Membership.mem",
"Exists",
"instOfNatNat",
... | [] | rintro ⟨d, hd₁, T, hT, rfl⟩
exact cons_mem_fixedLengthDigits_succ hb l d hd₁ hT | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 234,
"column": 2
} | {
"line": 234,
"column": 28
} | {
"line": 235,
"column": 2
} | [
{
"pp": "n : ℕ\nf : ℕ →₀ ℕ\nhn : n ≠ 0\nhf : ∀ p ∈ f.support, Prime p\n⊢ f = n.factorization ↔ (f.prod fun x1 x2 ↦ x1 ^ x2) = n",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"Nat.Prime",
"Finset",
"Nat.instMonoid",
"Finsupp.support",
... | [
"case mp\nn : ℕ\nhn : n ≠ 0\nhf : ∀ p ∈ n.factorization.support, Prime p\n⊢ (n.factorization.prod fun x1 x2 ↦ x1 ^ x2) = n",
"case mpr\nf : ℕ →₀ ℕ\nhf : ∀ p ∈ f.support, Prime p\nhn : (f.prod fun x1 x2 ↦ x1 ^ x2) ≠ 0\n⊢ f = (f.prod fun x1 x2 ↦ x1 ^ x2).factorization"
] | constructor <;> rintro rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Nat.Choose.Factorization | {
"line": 139,
"column": 24
} | {
"line": 139,
"column": 89
} | {
"line": 141,
"column": 0
} | [
{
"pp": "a b : ℕ\nhb : b ≠ 0\nk : ℕ\nhc : b * k ≠ 0\n⊢ b.factorization a ≤ (b * k).factorization a",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Nat.instMulZeroClass",
"Nat.instIsOrderedAddMonoid",
"LinearOrderedCommMonoidWithZero.toIsBotZe... | [] | simp [factorization_mul hb (Nat.ne_zero_of_mul_ne_zero_right hc)] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Nat.Choose.Factorization | {
"line": 223,
"column": 9
} | {
"line": 223,
"column": 69
} | {
"line": 223,
"column": 69
} | [
{
"pp": "p n k : ℕ\nhp' : p ≠ 2\nhk : p ≤ k\nhk' : p ≤ n - k\nhn : n < 3 * p\nhp : Prime p\nhkn : k ≤ n\nhi₁ : 1 ≤ 1\nhi : 1 < log p n + 1\n⊢ p * (k / p) + k % p + (p * ((n - k) / p) + (n - k) % p) < succ 2 * p",
"ppTerm": "?m.176",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.ins... | [] | by rwa [div_add_mod, div_add_mod, add_tsub_cancel_of_le hkn] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Choose.Factorization | {
"line": 217,
"column": 4
} | {
"line": 223,
"column": 70
} | {
"line": 224,
"column": 2
} | [
{
"pp": "case inr.inr.inl\np n k : ℕ\nhp' : p ≠ 2\nhk : p ≤ k\nhk' : p ≤ n - k\nhn : n < 3 * p\nhp : Prime p\nhkn : k ≤ n\nhi₁ : 1 ≤ 1\nhi : 1 < log p n + 1\n⊢ p + k % p + (p + (n - k) % p) < succ 2 * p",
"ppTerm": "?inr.inr.inl",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",... | [] | exact
lt_of_le_of_lt
(add_le_add
(add_le_add_left (le_mul_of_one_le_right' ((one_le_div_iff hp.pos).mpr hk)) (k % p))
(add_le_add_left (le_mul_of_one_le_right' ((one_le_div_iff hp.pos).mpr hk'))
((n - k) % p)))
(by rwa [div_add_mod, div_add_mod, add_tsub_cancel_of_l... | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.CharP.Lemmas | {
"line": 43,
"column": 8
} | {
"line": 43,
"column": 22
} | {
"line": 43,
"column": 23
} | [
{
"pp": "case 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)\nhk₀ : 0 < k\nhk : k < 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))",
"ppTerm": "?a✝",
"assigned": t... | [
"case 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)\nhk₀ : 0 < k\nhk : k < p ^ n\n⊢ x ^ k * y ^ (p ^ n - k) * ↑((p ^ n).choose k) = x ^ k * y ^ (p ^ n - k) * ↑((p ^ n).choose k / p) * ↑p"
] | Nat.cast_comm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.OrderOfElement | {
"line": 678,
"column": 4
} | {
"line": 686,
"column": 73
} | {
"line": 687,
"column": 2
} | [
{
"pp": "case mp\nG : Type u_1\ninst✝ : RightCancelMonoid G\nx : G\nm✝ n m k : ℕ\nhmn : m ≤ m + k\n⊢ x ^ (m + k) = x ^ m → m + k ≡ m [MOD orderOf x]",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Trans.trans",
"Dvd.dvd",
"HMul.hMul",
... | [] | intro h
have hk : x ^ k = 1 := by
apply (mul_right_cancel_iff (a := x ^ m)).1
calc
x ^ k * x ^ m = x ^ (k + m) := (pow_add _ _ _).symm
_ = x ^ (m + k) := by simp [Nat.add_comm]
_ = x ^ m := h
_ = 1 * x ^ m := by simp
exact by simpa using Nat.ModEq.add_left m (pow_eq_o... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.OrderOfElement | {
"line": 678,
"column": 4
} | {
"line": 686,
"column": 73
} | {
"line": 687,
"column": 2
} | [
{
"pp": "case mp\nG : Type u_1\ninst✝ : RightCancelMonoid G\nx : G\nm✝ n m k : ℕ\nhmn : m ≤ m + k\n⊢ x ^ (m + k) = x ^ m → m + k ≡ m [MOD orderOf x]",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Trans.trans",
"Dvd.dvd",
"HMul.hMul",
... | [] | intro h
have hk : x ^ k = 1 := by
apply (mul_right_cancel_iff (a := x ^ m)).1
calc
x ^ k * x ^ m = x ^ (k + m) := (pow_add _ _ _).symm
_ = x ^ (m + k) := by simp [Nat.add_comm]
_ = x ^ m := h
_ = 1 * x ^ m := by simp
exact by simpa using Nat.ModEq.add_left m (pow_eq_o... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Multiplicity | {
"line": 142,
"column": 2
} | {
"line": 146,
"column": 39
} | {
"line": 147,
"column": 2
} | [
{
"pp": "n p : ℕ\nhp : Prime p\nhp' : _root_.Prime p\nh0 : 2 ≤ p\nh1 : 1 ≤ p * n + 1\nh2 : p * n + 1 ≤ p * (n + 1)\nh3 : p * n + 1 ≤ p * (n + 1) + 1\n⊢ emultiplicity p (p * n)! ≠ ⊤ → emultiplicity p (p * (n + 1))! = emultiplicity p (p * n)! + emultiplicity p (n + 1) + 1",
"ppTerm": "?m.164",
"assigned":... | [
"n p : ℕ\nhp : Prime p\nhp' : _root_.Prime p\nh0 : 2 ≤ p\nh1 : 1 ≤ p * n + 1\nh2 : p * n + 1 ≤ p * (n + 1)\nh3 : p * n + 1 ≤ p * (n + 1) + 1\nh4 : ∀ m ∈ Ico (p * n + 1) (p * (n + 1)), emultiplicity p m = 0\n⊢ emultiplicity p (p * n)! ≠ ⊤ → emultiplicity p (p * (n + 1))! = emultiplicity p (p * n)! + emultiplicity p ... | have h4 : ∀ m ∈ Ico (p * n + 1) (p * (n + 1)), emultiplicity p m = 0 := by
intro m hm
rw [emultiplicity_eq_zero, not_dvd_iff_lt_mul_succ _ hp.pos]
rw [mem_Ico] at hm
exact ⟨n, lt_of_succ_le hm.1, hm.2⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Polynomial.Inductions | {
"line": 146,
"column": 8
} | {
"line": 146,
"column": 32
} | {
"line": 147,
"column": 8
} | [
{
"pp": "R : Type u\nS : Type v\nT : Type w\nA : Type z\na b : R\nn : ℕ\ninst✝ : Semiring R\np✝ q : R[X]\nM : R[X] → Sort u_1\np : R[X]\nM0 : M 0\nMC : (p : R[X]) → (a : R) → p.coeff 0 = 0 → a ≠ 0 → M p → M (p + C a)\nMX : (p : R[X]) → p ≠ 0 → M p → M (p * X)\nthis : DecidableEq R := Classical.decEq R\nhp : ¬p.... | [
"R : Type u\nS : Type v\nT : Type w\nA : Type z\na b : R\nn : ℕ\ninst✝ : Semiring R\np✝ q : R[X]\nM : R[X] → Sort u_1\np : R[X]\nM0 : M 0\nMC : (p : R[X]) → (a : R) → p.coeff 0 = 0 → a ≠ 0 → M p → M (p + C a)\nMX : (p : R[X]) → p ≠ 0 → M p → M (p * X)\nthis : DecidableEq R := Classical.decEq R\nhp : ¬p.divX * X + C... | rw [hcp0, C_0, add_zero] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.OrderOfElement | {
"line": 1451,
"column": 54
} | {
"line": 1451,
"column": 76
} | {
"line": 1451,
"column": 76
} | [
{
"pp": "R : Type u_6\ninst✝¹ : Ring R\ninst✝ : Fintype R\np n : ℕ\nhp : Fact (Nat.Prime p)\nhn : card R = p ^ n\nhR : ∀ i ≤ n, ↑p ^ i = 0 → i = n\nc : ℕ\nhc : CharP R c\nhcpn : c ∣ p ^ n\n⊢ ∃ i ≤ n, c = p ^ i",
"ppTerm": "?m.64",
"assigned": true,
"usedConstants": [
"Nat.Prime",
"Dvd.dv... | [
"R : Type u_6\ninst✝¹ : Ring R\ninst✝ : Fintype R\np n : ℕ\nhp : Fact (Nat.Prime p)\nhn : card R = p ^ n\nhR : ∀ i ≤ n, ↑p ^ i = 0 → i = n\nc : ℕ\nhc : CharP R c\nhcpn : ∃ k ≤ n, c = p ^ k\n⊢ ∃ i ≤ n, c = p ^ i"
] | Nat.dvd_prime_pow hp.1 | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Inductions | {
"line": 214,
"column": 20
} | {
"line": 214,
"column": 61
} | {
"line": 214,
"column": 61
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\nM : R[X] → Prop\nf : R[X]\nf0 : f.natDegree ≠ 0\nh_C_add : ∀ {a : R} {p : R[X]}, M p → M (C a + p)\nh_add : ∀ {p q : R[X]}, M p → M q → M (p + q)\nh_monomial : ∀ {n : ℕ} {a : R}, a ≠ 0 → n ≠ 0 → M ((monomial n) a)\nn : ℕ\na : R\na✝ : (C a * X ^ n).natDegree = 0 ∨ M (C a ... | [] | by rw [a0, C_0, zero_mul, natDegree_zero] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.RingDivision | {
"line": 281,
"column": 54
} | {
"line": 281,
"column": 78
} | {
"line": 281,
"column": 79
} | [
{
"pp": "R : Type u_1\ninst✝ : CommRing R\na b : R\nh : IsUnit (a - b)\n⊢ C ↑h.unit⁻¹ * (X - C b - (X - C a)) = 1",
"ppTerm": "?m.80",
"assigned": true,
"usedConstants": [
"Units.val",
"Eq.mpr",
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithOne",
"NonUnitalCommRi... | [
"R : Type u_1\ninst✝ : CommRing R\na b : R\nh : IsUnit (a - b)\n⊢ C ↑h.unit⁻¹ * (C a - C b) = 1"
] | sub_sub_sub_cancel_left, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Div | {
"line": 332,
"column": 2
} | {
"line": 347,
"column": 35
} | {
"line": 349,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\nf g : R[X]\nhg : g.Monic\n⊢ (f /ₘ g).natDegree = f.natDegree - g.natDegree",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Nontrivial",
"Iff.mpr",
"WithBot.addMonoidWithOne",
"WithBot.instPreorder",
"Eq.mpr",
"Nat.in... | [] | nontriviality R
by_cases hfg : f /ₘ g = 0
· rw [hfg, natDegree_zero]
rw [divByMonic_eq_zero_iff hg] at hfg
rw [tsub_eq_zero_iff_le.mpr (natDegree_le_natDegree <| le_of_lt hfg)]
have hgf := hfg
rw [divByMonic_eq_zero_iff hg] at hgf
push Not at hgf
have := degree_add_divByMonic hg hgf
have hf : f ≠ ... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Div | {
"line": 332,
"column": 2
} | {
"line": 347,
"column": 35
} | {
"line": 349,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\nf g : R[X]\nhg : g.Monic\n⊢ (f /ₘ g).natDegree = f.natDegree - g.natDegree",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Nontrivial",
"Iff.mpr",
"WithBot.addMonoidWithOne",
"WithBot.instPreorder",
"Eq.mpr",
"Nat.in... | [] | nontriviality R
by_cases hfg : f /ₘ g = 0
· rw [hfg, natDegree_zero]
rw [divByMonic_eq_zero_iff hg] at hfg
rw [tsub_eq_zero_iff_le.mpr (natDegree_le_natDegree <| le_of_lt hfg)]
have hgf := hfg
rw [divByMonic_eq_zero_iff hg] at hgf
push Not at hgf
have := degree_add_divByMonic hg hgf
have hf : f ≠ ... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Expand | {
"line": 312,
"column": 2
} | {
"line": 312,
"column": 27
} | {
"line": 312,
"column": 27
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\np : ℕ\nhp : 0 < p\nf : R[X]\nhf1 : IsUnit ((expand R p) f)\nhf2 : (expand R p) f = C (f.coeff 0)\n⊢ IsUnit f",
"ppTerm": "?m.60",
"assigned": true,
"usedConstants": [
"Polynomial.C",
"congrArg",
"CommSemiring.toSemiring"... | [
"R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\np : ℕ\nhp : 0 < p\nf : R[X]\nhf1 : IsUnit (f.coeff 0)\nhf2 : (expand R p) f = C (f.coeff 0)\n⊢ IsUnit f"
] | rw [hf2, isUnit_C] at hf1 | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Polynomial.Expand | {
"line": 325,
"column": 6
} | {
"line": 326,
"column": 25
} | {
"line": 328,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\np : ℕ\nhp : p ≠ 0\nf : R[X]\nn✝ n : ℕ\nih : Irreducible ((expand R (p ^ n)) f) → Irreducible f\nhf : Irreducible ((expand R (p ^ n.succ)) f)\n⊢ Irreducible ((expand R p) ((expand R (p ^ n)) f))",
"ppTerm": "?m.30",
"assigned": true,
"used... | [] | rw [pow_succ'] at hf
rwa [expand_expand] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Expand | {
"line": 325,
"column": 6
} | {
"line": 326,
"column": 25
} | {
"line": 328,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\np : ℕ\nhp : p ≠ 0\nf : R[X]\nn✝ n : ℕ\nih : Irreducible ((expand R (p ^ n)) f) → Irreducible f\nhf : Irreducible ((expand R (p ^ n.succ)) f)\n⊢ Irreducible ((expand R p) ((expand R (p ^ n)) f))",
"ppTerm": "?m.30",
"assigned": true,
"used... | [] | rw [pow_succ'] at hf
rwa [expand_expand] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Filter.Pi | {
"line": 191,
"column": 4
} | {
"line": 191,
"column": 15
} | {
"line": 192,
"column": 4
} | [
{
"pp": "case mp\nι : Type u_1\nα : ι → Type u_2\nf : (i : ι) → Filter (α i)\ns : (i : ι) → Set (α i)\n⊢ (∃ I, I.Finite ∧ ∃ t, (∀ (i : ι), t i ∈ f i) ∧ I.pi t ⊆ (univ.pi s)ᶜ) → ∃ i, (s i)ᶜ ∈ f i",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Filter.instMembership",
"Mathlib.Tac... | [
"case mp\nι : Type u_1\nα : ι → Type u_2\nf : (i : ι) → Filter (α i)\ns : (i : ι) → Set (α i)\n⊢ (∀ (i : ι), (s i)ᶜ ∉ f i) →\n ∀ (I : Set ι), I.Finite → ∀ (t : (i : ι) → Set (α i)), (∀ (i : ι), t i ∈ f i) → ¬I.pi t ⊆ (univ.pi s)ᶜ"
] | contrapose! | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.Order.Filter.Finite | {
"line": 287,
"column": 79
} | {
"line": 288,
"column": 59
} | {
"line": 290,
"column": 0
} | [
{
"pp": "α : Type u\nι : Type u_2\nf : Filter ι\ns : ι → Set α\nt : Set α\nht : t.Finite\nhs : ∀ a ∈ t, ∀ᶠ (i : ι) in f, a ∈ s i\n⊢ ∀ᶠ (i : ι) in f, t ⊆ s i",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Filter.Eventually",
"Membership.mem",
"id",
... | [] | by
simpa [Set.subset_def, eventually_all_finite ht] using hs | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Filter.Prod | {
"line": 237,
"column": 6
} | {
"line": 237,
"column": 17
} | {
"line": 237,
"column": 18
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nf : Filter α\ng : Filter β\n⊢ f ×ˢ g = map Prod.swap (g ×ˢ f)",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"SProd.sprod",
"congrArg",
"Filter.map",
"id",
"Prod.swap",
"Prod",
"Filter.instSProd... | [
"α : Type u_1\nβ : Type u_2\nf : Filter α\ng : Filter β\n⊢ comap Prod.swap (g ×ˢ f) = map Prod.swap (g ×ˢ f)"
] | prod_comm', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 667,
"column": 67
} | {
"line": 667,
"column": 89
} | {
"line": 669,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\n⊢ derivative (p.comp (1 - X)) = -(derivative p).comp (1 - X)",
"ppTerm": "?m.35",
"assigned": true,
"usedConstants": [
"Polynomial.derivative",
"Polynomial.instOne",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.... | [] | simp [derivative_comp] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 667,
"column": 67
} | {
"line": 667,
"column": 89
} | {
"line": 669,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\n⊢ derivative (p.comp (1 - X)) = -(derivative p).comp (1 - X)",
"ppTerm": "?m.35",
"assigned": true,
"usedConstants": [
"Polynomial.derivative",
"Polynomial.instOne",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.... | [] | simp [derivative_comp] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 667,
"column": 67
} | {
"line": 667,
"column": 89
} | {
"line": 669,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\n⊢ derivative (p.comp (1 - X)) = -(derivative p).comp (1 - X)",
"ppTerm": "?m.35",
"assigned": true,
"usedConstants": [
"Polynomial.derivative",
"Polynomial.instOne",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.... | [] | simp [derivative_comp] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Associated | {
"line": 112,
"column": 8
} | {
"line": 112,
"column": 15
} | {
"line": 112,
"column": 15
} | [
{
"pp": "case cons.inr.inl\nM₀ : Type u_3\ninst✝¹ : CommMonoidWithZero M₀\ninst✝ : IsCancelMulZero M₀\nc✝ : M₀\ns : Multiset M₀\nhind :\n ∀ (x y : M₀),\n x * y ∈ closure {r | IsUnit r ∨ Prime r} →\n (∀ y ∈ s, IsUnit y ∨ Prime y) → s.prod = x * y → x ∈ closure {r | IsUnit r ∨ Prime r}\nx y : M₀\nhxy : x... | [
"case cons.inr.inl\nM₀ : Type u_3\ninst✝¹ : CommMonoidWithZero M₀\ninst✝ : IsCancelMulZero M₀\nc✝ : M₀\ns : Multiset M₀\nhind :\n ∀ (x y : M₀),\n x * y ∈ closure {r | IsUnit r ∨ Prime r} →\n (∀ y ∈ s, IsUnit y ∨ Prime y) → s.prod = x * y → x ∈ closure {r | IsUnit r ∨ Prime r}\nx y : M₀\nhxy : x * y ∈ closu... | rw [hc] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 139,
"column": 6
} | {
"line": 139,
"column": 37
} | {
"line": 140,
"column": 4
} | [
{
"pp": "case inr.hg\nα : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\nh : Nontrivial α\nx : α\nhx : x ∈ 0\n⊢ False",
"ppTerm": "?inr.hg",
"assigned": true,
"usedConstants": [
"Multiset.notMem_zero"
],
"usedFVars": [
... | [] | apply Multiset.notMem_zero x hx | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.RingTheory.UniqueFactorizationDomain.Basic | {
"line": 136,
"column": 20
} | {
"line": 136,
"column": 33
} | {
"line": 136,
"column": 34
} | [
{
"pp": "case refine_1\nα : Type u_1\ninst✝ : CommMonoidWithZero α\na : α\nf : Multiset α\nha : Irreducible a\npfa : (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a\nthis : DecidableEq α\np : α\ns : Multiset α\na✝ : s.prod ~ᵤ a → (∀ b ∈ s, Prime b) → ∃ p, a ~ᵤ p ∧ s = {p}\nu : αˣ\nhu : (p ::ₘ s).prod * ↑u = a\nhs : ∀ b ∈ p ::... | [
"case refine_1\nα : Type u_1\ninst✝ : CommMonoidWithZero α\na : α\nf : Multiset α\nha : Irreducible a\npfa : (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a\nthis : DecidableEq α\np : α\ns : Multiset α\na✝ : s.prod ~ᵤ a → (∀ b ∈ s, Prime b) → ∃ p, a ~ᵤ p ∧ s = {p}\nu : αˣ\nhu : (p ::ₘ s).prod * ↑u = a\nhs : ∀ b ∈ p ::ₘ s, Prime b... | mul_comm p _, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Finsupp.Weight | {
"line": 326,
"column": 12
} | {
"line": 326,
"column": 47
} | {
"line": 327,
"column": 2
} | [
{
"pp": "case zero\nα : Type u_5\ns : Set α\n⊢ 0 • (fun x ↦ single x 1) '' s = {x | degree x = 0 ∧ ↑x.support ⊆ s}",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"Finsupp.instAddZeroClass",
"Set.ext",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Nat.instMulZer... | [] | aesop (add simp degree_eq_zero_iff) | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Data.Finsupp.Weight | {
"line": 326,
"column": 12
} | {
"line": 326,
"column": 47
} | {
"line": 327,
"column": 2
} | [
{
"pp": "case zero\nα : Type u_5\ns : Set α\n⊢ 0 • (fun x ↦ single x 1) '' s = {x | degree x = 0 ∧ ↑x.support ⊆ s}",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"Finsupp.instAddZeroClass",
"Set.ext",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Nat.instMulZer... | [] | aesop (add simp degree_eq_zero_iff) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finsupp.Weight | {
"line": 326,
"column": 12
} | {
"line": 326,
"column": 47
} | {
"line": 327,
"column": 2
} | [
{
"pp": "case zero\nα : Type u_5\ns : Set α\n⊢ 0 • (fun x ↦ single x 1) '' s = {x | degree x = 0 ∧ ↑x.support ⊆ s}",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"Finsupp.instAddZeroClass",
"Set.ext",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Nat.instMulZer... | [] | aesop (add simp degree_eq_zero_iff) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Roots | {
"line": 303,
"column": 2
} | {
"line": 304,
"column": 50
} | {
"line": 305,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\ns : Finset R\n⊢ (s.val.bind fun i ↦ (X - C i).roots) = s.val",
"ppTerm": "?m.55",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Polynomial.roots",
"Multiset.map",
"congrArg",
"CommSemi... | [
"R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\ns : Finset R\n⊢ ∏ a ∈ s, (X - C a) ≠ 0"
] | · simp_rw [roots_X_sub_C]
rw [Multiset.bind_singleton, Multiset.map_id'] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Polynomial.Roots | {
"line": 310,
"column": 2
} | {
"line": 311,
"column": 50
} | {
"line": 312,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\ns : Multiset R\n⊢ (s.bind fun a ↦ (X - C a).roots) = s",
"ppTerm": "?m.45",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Polynomial.roots",
"Multiset.map",
"congrArg",
"CommSemiring.t... | [
"case a\nR : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\ns : Multiset R\n⊢ 0 ∉ Multiset.map (fun a ↦ X - C a) s"
] | · simp_rw [roots_X_sub_C]
rw [Multiset.bind_singleton, Multiset.map_id'] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 276,
"column": 2
} | {
"line": 278,
"column": 28
} | {
"line": 280,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\na b c : α\nha : a ∈ normalizedFactors c\nhb : b ∈ normalizedFactors c\nh : a ~ᵤ b\n⊢ a = b",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Dvd.d... | [] | rw [← normalize_normalized_factor a ha, ← normalize_normalized_factor b hb,
normalize_eq_normalize_iff]
exact Associated.dvd_dvd h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 276,
"column": 2
} | {
"line": 278,
"column": 28
} | {
"line": 280,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\na b c : α\nha : a ∈ normalizedFactors c\nhb : b ∈ normalizedFactors c\nh : a ~ᵤ b\n⊢ a = b",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Dvd.d... | [] | rw [← normalize_normalized_factor a ha, ← normalize_normalized_factor b hb,
normalize_eq_normalize_iff]
exact Associated.dvd_dvd h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 281,
"column": 92
} | {
"line": 292,
"column": 87
} | {
"line": 294,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\nx : α\nhx : x ≠ 0\n⊢ 0 < normalizedFactors x ↔ ¬IsUnit x",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"UniqueFactorizationMonoid.normalizedFactors",
"Co... | [] | by
constructor
· intro h hx
obtain ⟨p, hp⟩ := Multiset.exists_mem_of_ne_zero h.ne'
exact
(prime_of_normalized_factor _ hp).not_isUnit
(isUnit_of_dvd_unit (dvd_of_mem_normalizedFactors hp) hx)
· intro h
obtain ⟨p, hp⟩ := exists_mem_normalizedFactors hx h
exact
bot_lt_iff_ne_bot.... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 328,
"column": 6
} | {
"line": 328,
"column": 45
} | {
"line": 329,
"column": 6
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\ns : Multiset α\nhs : 0 ∉ s\nh✝ : Subsingleton α\n⊢ s = 0",
"ppTerm": "?m.62",
"assigned": true,
"usedConstants": [
"Multiset.eq_zero_of_forall_notMem"
],
"usedFVar... | [
"α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\ns : Multiset α\nhs : 0 ∉ s\nh✝ : Subsingleton α\n⊢ ∀ (x : α), x ∉ s"
] | apply Multiset.eq_zero_of_forall_notMem | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 401,
"column": 8
} | {
"line": 402,
"column": 64
} | {
"line": 403,
"column": 8
} | [
{
"pp": "α : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\nx✝ : Associates α\nhx : ¬x✝ = 0\nx : Associates α\n⊢ (⇑Associates.mkMonoidHom ∘ Classical.choose ⋯) x = id x",
"ppTerm": "?m.115",
"assigned": true,
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
... | [
"α : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\nx✝ : Associates α\nhx : ¬x✝ = 0\nx : Associates α\n⊢ x = id x"
] | rw [Function.comp_apply, mkMonoidHom_apply,
Classical.choose_spec mk_surjective.hasRightInverse x] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.UniqueFactorizationDomain.Basic | {
"line": 396,
"column": 51
} | {
"line": 396,
"column": 65
} | {
"line": 396,
"column": 66
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : CommMonoidWithZero α\ninst✝ : CommMonoidWithZero β\ne : α ≃* β\nhα : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a\nthis : IsCancelMulZero β\na : β\nha : a ≠ 0\nw : Multiset α\nhp : ∀ b ∈ w, Prime b\nu : αˣ\nh : w.prod * ↑u = e.symm a\n⊢ e w.prod * ↑((Uni... | [
"α : Type u_1\nβ : Type u_2\ninst✝¹ : CommMonoidWithZero α\ninst✝ : CommMonoidWithZero β\ne : α ≃* β\nhα : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a\nthis : IsCancelMulZero β\na : β\nha : a ≠ 0\nw : Multiset α\nhp : ∀ b ∈ w, Prime b\nu : αˣ\nh : w.prod * ↑u = e.symm a\n⊢ e w.prod * ↑e ↑u = a"
] | Units.coe_map, | 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.