module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 365
values | kind stringclasses 368
values |
|---|---|---|---|---|---|---|
Mathlib.Algebra.MvPolynomial.Equiv | {
"line": 580,
"column": 2
} | {
"line": 599,
"column": 39
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nn : ℕ\nm : Fin n →₀ ℕ\nf : MvPolynomial (Fin (n + 1)) R\ni : ℕ\n⊢ coeff m (((finSuccEquiv R n) f).coeff i) = coeff (cons i m) f",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Finsupp.instFunLike",
"Eq.mpr",
"Polynomial.C",
"AlgEqu... | induction f using MvPolynomial.induction_on' generalizing i m with
| add p q hp hq => simp only [map_add, Polynomial.coeff_add, coeff_add, hp, hq]
| monomial j r =>
simp only [finSuccEquiv_apply, coe_eval₂Hom, eval₂_monomial, RingHom.coe_comp, Finsupp.prod_pow,
Polynomial.coeff_C_mul, coeff_C_mul, coeff_m... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MvPolynomial.Equiv | {
"line": 580,
"column": 2
} | {
"line": 599,
"column": 39
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nn : ℕ\nm : Fin n →₀ ℕ\nf : MvPolynomial (Fin (n + 1)) R\ni : ℕ\n⊢ coeff m (((finSuccEquiv R n) f).coeff i) = coeff (cons i m) f",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Finsupp.instFunLike",
"Eq.mpr",
"Polynomial.C",
"AlgEqu... | induction f using MvPolynomial.induction_on' generalizing i m with
| add p q hp hq => simp only [map_add, Polynomial.coeff_add, coeff_add, hp, hq]
| monomial j r =>
simp only [finSuccEquiv_apply, coe_eval₂Hom, eval₂_monomial, RingHom.coe_comp, Finsupp.prod_pow,
Polynomial.coeff_C_mul, coeff_C_mul, coeff_m... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.EraseLead | {
"line": 393,
"column": 2
} | {
"line": 394,
"column": 23
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\nn : ℕ\nk : Fin n → ℕ\nx : Fin n → R\nhk : Function.Injective k\nhx : ∀ (i : Fin n), x i ≠ 0\n⊢ (∑ i, C (x i) * X ^ k i).support = image k univ",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"_private.Mathlib.Algebra.Polynomial.EraseLead.0.Polynomi... | simp_rw [Finset.ext_iff, mem_support_iff, finset_sum_coeff, coeff_C_mul_X_pow, mem_image,
mem_univ, true_and] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Algebra.Polynomial.EraseLead | {
"line": 446,
"column": 64
} | {
"line": 446,
"column": 89
} | [
{
"pp": "case succ.refine_3\nR : Type u_1\ninst✝ : Semiring R\nn : ℕ\nhn : ∀ {f : R[X]}, #f.support = n → ∃ k x, ∃ (_ : StrictMono k) (_ : ∀ (i : Fin n), x i ≠ 0), f = ∑ i, C (x i) * X ^ k i\nf : R[X]\nh : #f.support = n + 1\nk : Fin n → ℕ\nx : Fin n → R\nhk : StrictMono k\nhx : ∀ (i : Fin n), x i ≠ 0\nhf : f.e... | eraseLead_add_C_mul_X_pow | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.EraseLead | {
"line": 472,
"column": 55
} | {
"line": 481,
"column": 49
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\nf : R[X]\n⊢ #f.support = 3 ↔\n ∃ k m n,\n ∃ (_ : k < m) (_ : m < n),\n ∃ x y z, ∃ (_ : x ≠ 0) (_ : y ≠ 0) (_ : z ≠ 0), f = C x * X ^ k + C y * X ^ m + C z * X ^ n",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Fin.sum_univ_castSucc... | by
refine ⟨fun h => ?_, ?_⟩
· obtain ⟨k, x, hk, hx, rfl⟩ := card_support_eq.mp h
refine
⟨k 0, k 1, k 2, hk Nat.zero_lt_one, hk (Nat.lt_succ_self 1), x 0, x 1, x 2, hx 0, hx 1, hx 2,
?_⟩
rw [Fin.sum_univ_castSucc, Fin.sum_univ_castSucc, Fin.sum_univ_one]
rfl
· rintro ⟨k, m, n, hkm, hmn, x... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 441,
"column": 6
} | {
"line": 441,
"column": 20
} | [
{
"pp": "case h\nR : Type u\nS : Type u_1\ninst✝¹ : CommSemiring R\ninst✝ : Semiring S\nf : R →+* S\nx✝ : R[X]\n⊢ Polynomial.map f x✝ = 0 ↔ x✝ ∈ map C (RingHom.ker f)",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"RingHom.instRingHomClass",
"Semiring.toModule",
"congrArg",
... | mem_map_C_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 566,
"column": 30
} | {
"line": 566,
"column": 44
} | [
{
"pp": "case mpr.ne_top'\nR : Type u\ninst✝ : CommRing R\nP : Ideal R\nh : P.IsPrime\n⊢ 1 ∉ map C P",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Semiring.toModule",
"congrArg",
"CommSemiring.toSemiring",
"RingHom",
... | mem_map_C_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 631,
"column": 4
} | {
"line": 631,
"column": 9
} | [
{
"pp": "case a\nR : Type u\ninst✝ : Semiring R\nf : R[X]\np : Ideal R[X] := Ideal.span {g | ∃ i, g = C (f.coeff i)}\nn : ℕ\n_hn : n ∈ f.support\n⊢ ∃ i, C (f.coeff n) = C (f.coeff i)",
"usedConstants": [
"Polynomial.C",
"RingHom",
"Polynomial",
"Polynomial.coeff",
"RingHom.inst... | use n | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 624,
"column": 2
} | {
"line": 635,
"column": 32
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\nf : R[X]\n⊢ f ∈ Ideal.span {g | ∃ i, g = C (f.coeff i)}",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Submodule",
"instHSMul",
"Semiring.toModule",
"HMul.hMul",
"outParam",
... | let p := Ideal.span { g : R[X] | ∃ i : ℕ, g = C (coeff f i) }
nth_rw 2 [(sum_C_mul_X_pow_eq f).symm]
refine Submodule.sum_mem _ fun n _hn => ?_
dsimp
have : C (coeff f n) ∈ p := by
apply subset_span
rw [mem_setOf_eq]
use n
have : monomial n (1 : R) • C (coeff f n) ∈ p := p.smul_mem _ this
conver... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 624,
"column": 2
} | {
"line": 635,
"column": 32
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\nf : R[X]\n⊢ f ∈ Ideal.span {g | ∃ i, g = C (f.coeff i)}",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Submodule",
"instHSMul",
"Semiring.toModule",
"HMul.hMul",
"outParam",
... | let p := Ideal.span { g : R[X] | ∃ i : ℕ, g = C (coeff f i) }
nth_rw 2 [(sum_C_mul_X_pow_eq f).symm]
refine Submodule.sum_mem _ fun n _hn => ?_
dsimp
have : C (coeff f n) ∈ p := by
apply subset_span
rw [mem_setOf_eq]
use n
have : monomial n (1 : R) • C (coeff f n) ∈ p := p.smul_mem _ this
conver... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 760,
"column": 8
} | {
"line": 762,
"column": 84
} | [
{
"pp": "case h.inl\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 : ℕ), I.lea... | · subst k
refine hs2 ⟨Polynomial.mem_degreeLE.2
(le_trans Polynomial.degree_le_natDegree <| WithBot.coe_le_coe.2 h), hp⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Ring.Subsemiring.MulOpposite | {
"line": 145,
"column": 86
} | {
"line": 148,
"column": 42
} | [
{
"pp": "R : Type u_2\ninst✝ : NonAssocSemiring R\ns : Set R\n⊢ (closure s).op = closure (MulOpposite.unop ⁻¹' s)",
"usedConstants": [
"Eq.mpr",
"Subsemiring.instSetLike",
"Function.Surjective.forall",
"Subsemiring.closure",
"congrArg",
"Subsemiring.op_sInf",
"MulOp... | by
simp_rw [closure, op_sInf, Set.preimage_setOf_eq, coe_unop]
congr with a
exact MulOpposite.unop_surjective.forall | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Ring.Subring.MulOpposite | {
"line": 139,
"column": 86
} | {
"line": 142,
"column": 42
} | [
{
"pp": "R : Type u_2\ninst✝ : NonAssocRing R\ns : Set R\n⊢ (closure s).op = closure (MulOpposite.unop ⁻¹' s)",
"usedConstants": [
"Eq.mpr",
"Function.Surjective.forall",
"Subring.instSetLike",
"congrArg",
"MulOpposite",
"setOf",
"Membership.mem",
"Eq.rec",
... | by
simp_rw [closure, op_sInf, Set.preimage_setOf_eq, coe_unop]
congr with a
exact MulOpposite.unop_surjective.forall | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 891,
"column": 4
} | {
"line": 891,
"column": 39
} | [
{
"pp": "σ : Type v\nR : Type u_2\ninst✝ : CommSemiring R\nm n : ℕ\nF : MvPolynomial σ R\nhF : F.totalDegree ≤ m\nf : σ → R[X]\nhf : ∀ (i : σ), (f i).natDegree ≤ n\nd : σ →₀ ℕ\nhd : d ∈ F.support\n⊢ ∑ i ∈ d.support, d i ≤ F.support.sup fun s ↦ s.sum fun x e ↦ e",
"usedConstants": [
"Finsupp.instFunLik... | exact Finset.le_sup_of_le hd le_rfl | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.FiniteType | {
"line": 343,
"column": 2
} | {
"line": 350,
"column": 48
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝¹ : CommSemiring R\ninst✝ : AddMonoid M\nS : Set R[M]\nhS : adjoin R S = ⊤\n⊢ adjoin R (⋃ f ∈ S, of' R M '' ↑f.support) = ⊤",
"usedConstants": [
"Subalgebra.instSetLike",
"Iff.mpr",
"Eq.mpr",
"AddMonoidAlgebra.semiring",
"Lattice.toSemi... | refine le_antisymm le_top ?_
rw [← hS, adjoin_le_iff]
intro f hf
have hincl :
of' R M '' f.support ⊆ ⋃ (g : R[M]) (_ : g ∈ S), of' R M '' g.support := by
intro s hs
exact Set.mem_iUnion₂.2 ⟨f, ⟨hf, hs⟩⟩
exact adjoin_mono hincl (mem_adjoin_support f) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.FiniteType | {
"line": 343,
"column": 2
} | {
"line": 350,
"column": 48
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝¹ : CommSemiring R\ninst✝ : AddMonoid M\nS : Set R[M]\nhS : adjoin R S = ⊤\n⊢ adjoin R (⋃ f ∈ S, of' R M '' ↑f.support) = ⊤",
"usedConstants": [
"Subalgebra.instSetLike",
"Iff.mpr",
"Eq.mpr",
"AddMonoidAlgebra.semiring",
"Lattice.toSemi... | refine le_antisymm le_top ?_
rw [← hS, adjoin_le_iff]
intro f hf
have hincl :
of' R M '' f.support ⊆ ⋃ (g : R[M]) (_ : g ∈ S), of' R M '' g.support := by
intro s hs
exact Set.mem_iUnion₂.2 ⟨f, ⟨hf, hs⟩⟩
exact adjoin_mono hincl (mem_adjoin_support f) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Algebra.Subalgebra.Pointwise | {
"line": 55,
"column": 4
} | {
"line": 56,
"column": 71
} | [
{
"pp": "case refine_1.inl\nR : Type u_3\nA : Type u_4\ninst✝² : CommSemiring R\ninst✝¹ : CommSemiring A\ninst✝ : Algebra R A\nS T : Subalgebra R A\nx✝ : A\nhx : x✝ ∈ Algebra.adjoin R (↑S ∪ ↑T)\nx : A\nhxS : x ∈ ↑S\n⊢ x ∈ toSubmodule S * toSubmodule T",
"usedConstants": [
"Subalgebra.instSetLike",
... | · rw [← mul_one x]
exact Submodule.mul_mem_mul hxS (show (1 : A) ∈ T from one_mem T) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Int.ModEq | {
"line": 396,
"column": 20
} | {
"line": 396,
"column": 45
} | [
{
"pp": "case left\na b : ℤ\nhb : 0 < b\nz : ℤ\nhz1 : 0 ≤ z\nhz2 : z < b\nhz3 : z ≡ a [ZMOD b]\n⊢ ↑z.natAbs < b",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Int",
"Nat.cast",
"Int.natAbs_of_nonneg",
"Int.instLTInt",
"LT.lt",
"Int.natAbs",
"ins... | rw [natAbs_of_nonneg hz1] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Int.ModEq | {
"line": 396,
"column": 20
} | {
"line": 396,
"column": 45
} | [
{
"pp": "case right\na b : ℤ\nhb : 0 < b\nz : ℤ\nhz1 : 0 ≤ z\nhz2 : z < b\nhz3 : z ≡ a [ZMOD b]\n⊢ ↑z.natAbs ≡ a [ZMOD b]",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Int",
"Nat.cast",
"Int.natAbs_of_nonneg",
"Int.ModEq",
"Int.natAbs",
"instNatCastI... | rw [natAbs_of_nonneg hz1] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Algebra.Subalgebra.Unitization | {
"line": 146,
"column": 4
} | {
"line": 148,
"column": 31
} | [
{
"pp": "case refine_2\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... | · obtain (⟨a, ha⟩ : (x : A) ∈ (unitization s).range) :=
(unitization_range s).ge x.property
exact ⟨a, Subtype.ext ha⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.Ideal.Quotient.Operations | {
"line": 154,
"column": 4
} | {
"line": 154,
"column": 79
} | [
{
"pp": "case h.mpr\nR : Type u\nS : Type v\ninst✝² : Ring R\ninst✝¹ : Semiring S\nI : Ideal R\ninst✝ : I.IsTwoSided\nf : R →+* S\nH : I ≤ ker f\nx : R ⧸ I\nhx : x ∈ map (Quotient.mk I) (ker f)\n⊢ x ∈ ker (Quotient.lift I f H)",
"usedConstants": [
"RingHom.instRingHomClass",
"Semiring.toModule",... | rw [mem_map_iff_of_surjective (Quotient.mk I) Quotient.mk_surjective] at hx | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Algebra.Subalgebra.Unitization | {
"line": 271,
"column": 4
} | {
"line": 273,
"column": 31
} | [
{
"pp": "case refine_2\nR : Type u_1\nS : Type u_2\nA : Type u_3\ninst✝⁷ : Field R\ninst✝⁶ : StarRing R\ninst✝⁵ : Ring A\ninst✝⁴ : StarRing A\ninst✝³ : Algebra R A\ninst✝² : StarModule R A\ninst✝¹ : SetLike S A\nhSA : NonUnitalSubringClass S A\nhSRA : SMulMemClass S R A\ninst✝ : StarMemClass S A\ns : S\nh1 : 1 ... | · obtain (⟨a, ha⟩ : (x : A) ∈ (unitization s).range) :=
(unitization_range s).ge x.property
exact ⟨a, Subtype.ext ha⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Star.Subalgebra | {
"line": 438,
"column": 8
} | {
"line": 438,
"column": 23
} | [
{
"pp": "F : Type u_1\nR : Type u_2\nA : Type u_3\nB : Type u_4\ninst✝⁹ : CommSemiring R\ninst✝⁸ : StarRing R\ninst✝⁷ : Semiring A\ninst✝⁶ : Algebra R A\ninst✝⁵ : StarRing A\ninst✝⁴ : StarModule R A\ninst✝³ : Semiring B\ninst✝² : Algebra R B\ninst✝¹ : StarRing B\ninst✝ : StarModule R B\ns : Set A\na✝ : A\nhx : ... | Set.union_star, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Ideal.Quotient.Operations | {
"line": 418,
"column": 63
} | {
"line": 418,
"column": 70
} | [
{
"pp": "A : Type u_3\ninst✝¹ : Ring A\nI : Ideal A\ninst✝ : I.IsTwoSided\nh : I = ⊥\n⊢ ker (mk I) = ⊥",
"usedConstants": [
"Eq.mpr",
"RingHom.instRingHomClass",
"Semiring.toModule",
"congrArg",
"Ideal.Quotient.mk",
"RingHom",
"id",
"Bot.bot",
"Ideal",
... | mk_ker, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Ideal.Quotient.Operations | {
"line": 779,
"column": 73
} | {
"line": 781,
"column": 5
} | [
{
"pp": "R₁ : Type u_1\nA : Type u_3\ninst✝⁴ : CommSemiring R₁\ninst✝³ : Ring A\ninst✝² : Algebra R₁ A\nI J : Ideal A\ninst✝¹ : I.IsTwoSided\ninst✝ : J.IsTwoSided\nh : I = J\n⊢ (quotientEquivAlgOfEq R₁ h).symm = quotientEquivAlgOfEq R₁ ⋯",
"usedConstants": [
"Ideal.quotientEquivAlgOfEq",
"AlgEqu... | by
ext
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Ideal.Quotient.Operations | {
"line": 882,
"column": 74
} | {
"line": 882,
"column": 81
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\nI J : Ideal R\n⊢ comap (Ideal.Quotient.mk I) (RingHom.ker (Ideal.Quotient.mk (map (Ideal.Quotient.mk I) J))) = I ⊔ J",
"usedConstants": [
"Eq.mpr",
"RingHom.instRingHomClass",
"congrArg",
"CommSemiring.toSemiring",
"Ideal.Quotient.mk",
... | mk_ker, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Ideal.Quotient.Operations | {
"line": 884,
"column": 4
} | {
"line": 884,
"column": 11
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\nI J : Ideal R\n⊢ J ⊔ RingHom.ker (Ideal.Quotient.mk I) = I ⊔ J",
"usedConstants": [
"Eq.mpr",
"RingHom.instRingHomClass",
"Lattice.toSemilatticeSup",
"Semiring.toModule",
"congrArg",
"CommSemiring.toSemiring",
"Ideal.Quotient... | mk_ker, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.GCDMonoid.Multiset | {
"line": 187,
"column": 32
} | {
"line": 187,
"column": 42
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizedGCDMonoid α\ninst✝ : DecidableEq α\ns₁ s₂ : Multiset α\n⊢ (dedup ?m.27).gcd = GCDMonoid.gcd s₁.gcd s₂.gcd",
"usedConstants": [
"Eq.mpr",
"Multiset.gcd_dedup",
"Multiset.gcd",
"congrArg",
"Multiset.dedup",
... | gcd_dedup, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.GCDMonoid.Multiset | {
"line": 192,
"column": 32
} | {
"line": 192,
"column": 42
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizedGCDMonoid α\ninst✝ : DecidableEq α\ns₁ s₂ : Multiset α\n⊢ (dedup ?m.27).gcd = GCDMonoid.gcd s₁.gcd s₂.gcd",
"usedConstants": [
"Eq.mpr",
"Multiset.gcd_dedup",
"Multiset.gcd",
"congrArg",
"Multiset.dedup",
... | gcd_dedup, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Ideal.Quotient.Operations | {
"line": 949,
"column": 90
} | {
"line": 951,
"column": 5
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\nI J : Ideal R\nh : I ≤ J\n⊢ (↑(quotQuotEquivQuotOfLE h)).comp (quotQuotMk I J) = Ideal.Quotient.mk J",
"usedConstants": [
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"CommSemiring.toSemiring",
"Ideal.Quotie... | by
ext
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Ideal.Quotient.Operations | {
"line": 954,
"column": 93
} | {
"line": 956,
"column": 5
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\nI J : Ideal R\nh : I ≤ J\n⊢ (↑(quotQuotEquivQuotOfLE h).symm).comp (Ideal.Quotient.mk J) = quotQuotMk I J",
"usedConstants": [
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"CommSemiring.toSemiring",
"Ideal.Q... | by
ext
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.GCDMonoid.Multiset | {
"line": 197,
"column": 32
} | {
"line": 197,
"column": 42
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizedGCDMonoid α\ninst✝ : DecidableEq α\na : α\ns : Multiset α\n⊢ (dedup ?m.24).gcd = GCDMonoid.gcd a s.gcd",
"usedConstants": [
"Eq.mpr",
"Multiset.gcd_dedup",
"Multiset.gcd",
"congrArg",
"Multiset.dedup",
... | gcd_dedup, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Prime.Basic | {
"line": 166,
"column": 2
} | {
"line": 168,
"column": 72
} | [
{
"pp": "p a k : ℕ\nhp : Prime p\n⊢ a ^ k = p ↔ a = p ∧ k = 1",
"usedConstants": [
"Eq.mpr",
"Nat.Prime",
"and_true",
"congrArg",
"Nat.instMonoid",
"Eq.mp",
"id",
"instOfNatNat",
"Nat.Prime.eq_one_of_pow",
"Monoid.toPow",
"And",
"HPow.h... | refine ⟨fun h => ?_, fun h => by rw [h.1, h.2, pow_one]⟩
rw [← h] at hp
rw [← h, hp.eq_one_of_pow, eq_self_iff_true, _root_.and_true, pow_one] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Prime.Basic | {
"line": 166,
"column": 2
} | {
"line": 168,
"column": 72
} | [
{
"pp": "p a k : ℕ\nhp : Prime p\n⊢ a ^ k = p ↔ a = p ∧ k = 1",
"usedConstants": [
"Eq.mpr",
"Nat.Prime",
"and_true",
"congrArg",
"Nat.instMonoid",
"Eq.mp",
"id",
"instOfNatNat",
"Nat.Prime.eq_one_of_pow",
"Monoid.toPow",
"And",
"HPow.h... | refine ⟨fun h => ?_, fun h => by rw [h.1, h.2, pow_one]⟩
rw [← h] at hp
rw [← h, hp.eq_one_of_pow, eq_self_iff_true, _root_.and_true, pow_one] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Dynamics.PeriodicPts.Defs | {
"line": 161,
"column": 4
} | {
"line": 161,
"column": 27
} | [
{
"pp": "case refine_1\nα : Type u_1\nf : α → α\nx : α\nm n✝ n : ℕ\nx✝ : IsPeriodicPt f 0 x\nhn : IsPeriodicPt f n x\n⊢ IsPeriodicPt f (Nat.gcd 0 n) x",
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
"congrArg",
"id",
"instOfNatNat",
"Function.IsPeriodicPt",
"Nat",
"... | rwa [Nat.gcd_zero_left] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Dynamics.PeriodicPts.Defs | {
"line": 161,
"column": 4
} | {
"line": 161,
"column": 27
} | [
{
"pp": "case refine_1\nα : Type u_1\nf : α → α\nx : α\nm n✝ n : ℕ\nx✝ : IsPeriodicPt f 0 x\nhn : IsPeriodicPt f n x\n⊢ IsPeriodicPt f (Nat.gcd 0 n) x",
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
"congrArg",
"id",
"instOfNatNat",
"Function.IsPeriodicPt",
"Nat",
"... | rwa [Nat.gcd_zero_left] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.PeriodicPts.Defs | {
"line": 161,
"column": 4
} | {
"line": 161,
"column": 27
} | [
{
"pp": "case refine_1\nα : Type u_1\nf : α → α\nx : α\nm n✝ n : ℕ\nx✝ : IsPeriodicPt f 0 x\nhn : IsPeriodicPt f n x\n⊢ IsPeriodicPt f (Nat.gcd 0 n) x",
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
"congrArg",
"id",
"instOfNatNat",
"Function.IsPeriodicPt",
"Nat",
"... | rwa [Nat.gcd_zero_left] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Dynamics.PeriodicPts.Defs | {
"line": 162,
"column": 4
} | {
"line": 163,
"column": 27
} | [
{
"pp": "case refine_2\nα : Type u_1\nf : α → α\nx : α\nm✝ n✝ m n : ℕ\nx✝ : 0 < m\nih : IsPeriodicPt f (n % m) x → IsPeriodicPt f m x → IsPeriodicPt f ((n % m).gcd m) x\nhm : IsPeriodicPt f m x\nhn : IsPeriodicPt f n x\n⊢ IsPeriodicPt f (m.gcd n) x",
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
... | rw [Nat.gcd_rec]
exact ih (hn.mod hm) hm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.PeriodicPts.Defs | {
"line": 162,
"column": 4
} | {
"line": 163,
"column": 27
} | [
{
"pp": "case refine_2\nα : Type u_1\nf : α → α\nx : α\nm✝ n✝ m n : ℕ\nx✝ : 0 < m\nih : IsPeriodicPt f (n % m) x → IsPeriodicPt f m x → IsPeriodicPt f ((n % m).gcd m) x\nhm : IsPeriodicPt f m x\nhn : IsPeriodicPt f n x\n⊢ IsPeriodicPt f (m.gcd n) x",
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
... | rw [Nat.gcd_rec]
exact ih (hn.mod hm) hm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Dynamics.PeriodicPts.Defs | {
"line": 472,
"column": 40
} | {
"line": 472,
"column": 56
} | [
{
"pp": "case pos\nα : Type u_1\nr : α → α → Prop\nf : α → α\nx : α\nhx : x ∈ periodicPts f\nhx' : 0 < minimalPeriod f x\nhM : minimalPeriod f x - succ 0 + succ 0 = minimalPeriod f x\n⊢ Cycle.Chain r (Cycle.map (fun n ↦ f^[n] x) ↑(List.range (minimalPeriod f x))) ↔\n ∀ n < minimalPeriod f x, r (f^[n] x) (f^[... | Cycle.chain_map, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.PeriodicPts.Defs | {
"line": 609,
"column": 18
} | {
"line": 609,
"column": 57
} | [
{
"pp": "α : Type v\nG : Type u\ninst✝¹ : Group G\ninst✝ : MulAction G α\nj : ℤ\ng : G\na : α\n| g ^ j • a",
"usedConstants": [
"Int.instDiv",
"instHSMul",
"instHDiv",
"HMul.hMul",
"congrArg",
"DivInvMonoid.toZPow",
"HDiv.hDiv",
"instHMod",
"DivInvMonoid... | ← Int.emod_add_mul_ediv j (period g a), | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.Data.Nat.Log | {
"line": 433,
"column": 4
} | {
"line": 433,
"column": 31
} | [
{
"pp": "case inr\nb x y : ℕ\nh : x ≤ b ^ y\nhb : 1 ≥ b\n⊢ clog b x ≤ y",
"usedConstants": [
"_private.Mathlib.Data.Nat.Log.0.Nat.clog_le_of_le_pow._proof_1_1"
]
}
] | grind [clog_of_left_le_one] | Lean.Elab.Tactic.evalGrind | Lean.Parser.Tactic.grind |
Mathlib.Data.Nat.Log | {
"line": 433,
"column": 4
} | {
"line": 433,
"column": 31
} | [
{
"pp": "case inr\nb x y : ℕ\nh : x ≤ b ^ y\nhb : 1 ≥ b\n⊢ clog b x ≤ y",
"usedConstants": [
"_private.Mathlib.Data.Nat.Log.0.Nat.clog_le_of_le_pow._proof_1_1"
]
}
] | grind [clog_of_left_le_one] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Log | {
"line": 433,
"column": 4
} | {
"line": 433,
"column": 31
} | [
{
"pp": "case inr\nb x y : ℕ\nh : x ≤ b ^ y\nhb : 1 ≥ b\n⊢ clog b x ≤ y",
"usedConstants": [
"_private.Mathlib.Data.Nat.Log.0.Nat.clog_le_of_le_pow._proof_1_1"
]
}
] | grind [clog_of_left_le_one] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Cycle | {
"line": 382,
"column": 4
} | {
"line": 384,
"column": 48
} | [
{
"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⊢ (pmap l.reverse.prev l.reverse ⋯)[l.length - 1 - k] = (l.rotate 1)[k]",
"usedConstants": [
"Iff.mpr",
"Nat.succ_pos'",
"... | simp_rw [pmap_prev_eq_rotate_length_sub_one _ (nodup_reverse.mpr h), rotate_reverse,
length_reverse, Nat.mod_eq_of_lt (Nat.sub_lt lpos Nat.succ_pos'),
Nat.sub_sub_self (Nat.succ_le_of_lt lpos)] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Data.Nat.Factors | {
"line": 210,
"column": 4
} | {
"line": 210,
"column": 40
} | [
{
"pp": "case inr.inl\na : ℕ\nha : a > 0\nhab : a.Coprime 0\n⊢ (a * 0).primeFactorsList ~ a.primeFactorsList ++ primeFactorsList 0",
"usedConstants": [
"Nat.Coprime",
"Nat.instMulZeroClass",
"Nat.coprime_zero_right",
"List.Perm.refl._simp_1",
"HMul.hMul",
"congrArg",
... | simp [(coprime_zero_right _).mp hab] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Nat.Factors | {
"line": 210,
"column": 4
} | {
"line": 210,
"column": 40
} | [
{
"pp": "case inr.inl\na : ℕ\nha : a > 0\nhab : a.Coprime 0\n⊢ (a * 0).primeFactorsList ~ a.primeFactorsList ++ primeFactorsList 0",
"usedConstants": [
"Nat.Coprime",
"Nat.instMulZeroClass",
"Nat.coprime_zero_right",
"List.Perm.refl._simp_1",
"HMul.hMul",
"congrArg",
... | simp [(coprime_zero_right _).mp hab] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factors | {
"line": 210,
"column": 4
} | {
"line": 210,
"column": 40
} | [
{
"pp": "case inr.inl\na : ℕ\nha : a > 0\nhab : a.Coprime 0\n⊢ (a * 0).primeFactorsList ~ a.primeFactorsList ++ primeFactorsList 0",
"usedConstants": [
"Nat.Coprime",
"Nat.instMulZeroClass",
"Nat.coprime_zero_right",
"List.Perm.refl._simp_1",
"HMul.hMul",
"congrArg",
... | simp [(coprime_zero_right _).mp hab] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Factors | {
"line": 287,
"column": 4
} | {
"line": 287,
"column": 40
} | [
{
"pp": "case inr.inl\na p : ℕ\nha : a > 0\nhab : a.Coprime 0\n⊢ p ∈ (a * 0).primeFactorsList ↔ p ∈ a.primeFactorsList ∪ primeFactorsList 0",
"usedConstants": [
"List.nil_union",
"Nat.Coprime",
"False",
"Nat.instMulZeroClass",
"Nat.coprime_zero_right",
"HMul.hMul",
... | simp [(coprime_zero_right _).mp hab] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Nat.Factors | {
"line": 287,
"column": 4
} | {
"line": 287,
"column": 40
} | [
{
"pp": "case inr.inl\na p : ℕ\nha : a > 0\nhab : a.Coprime 0\n⊢ p ∈ (a * 0).primeFactorsList ↔ p ∈ a.primeFactorsList ∪ primeFactorsList 0",
"usedConstants": [
"List.nil_union",
"Nat.Coprime",
"False",
"Nat.instMulZeroClass",
"Nat.coprime_zero_right",
"HMul.hMul",
... | simp [(coprime_zero_right _).mp hab] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factors | {
"line": 287,
"column": 4
} | {
"line": 287,
"column": 40
} | [
{
"pp": "case inr.inl\na p : ℕ\nha : a > 0\nhab : a.Coprime 0\n⊢ p ∈ (a * 0).primeFactorsList ↔ p ∈ a.primeFactorsList ∪ primeFactorsList 0",
"usedConstants": [
"List.nil_union",
"Nat.Coprime",
"False",
"Nat.instMulZeroClass",
"Nat.coprime_zero_right",
"HMul.hMul",
... | simp [(coprime_zero_right _).mp hab] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Index | {
"line": 853,
"column": 2
} | {
"line": 856,
"column": 100
} | [
{
"pp": "G : Type u_1\nM : Type u_2\ninst✝³ : Group G\ninst✝² : Group M\ninst✝¹ : Finite G\ninst✝ : Finite M\nf : G →* M\nh : Nat.card ↥f.ker ≤ Nat.card G / Nat.card M\n⊢ Function.Surjective ⇑f",
"usedConstants": [
"Eq.mpr",
"MonoidHom.range",
"QuotientGroup.quotientKerEquivRange",
"... | refine range_eq_top.1 <| SetLike.ext' <| Set.eq_of_subset_of_ncard_le (Set.subset_univ _) ?_
rw [Subgroup.coe_top, Set.ncard_univ, ← Nat.card_coe_set_eq, SetLike.coe_sort_coe,
← Nat.card_congr (QuotientGroup.quotientKerEquivRange f).toEquiv]
exact Nat.le_of_mul_le_mul_left (f.ker.card_mul_index ▸ Nat.mul_le_of_... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Index | {
"line": 853,
"column": 2
} | {
"line": 856,
"column": 100
} | [
{
"pp": "G : Type u_1\nM : Type u_2\ninst✝³ : Group G\ninst✝² : Group M\ninst✝¹ : Finite G\ninst✝ : Finite M\nf : G →* M\nh : Nat.card ↥f.ker ≤ Nat.card G / Nat.card M\n⊢ Function.Surjective ⇑f",
"usedConstants": [
"Eq.mpr",
"MonoidHom.range",
"QuotientGroup.quotientKerEquivRange",
"... | refine range_eq_top.1 <| SetLike.ext' <| Set.eq_of_subset_of_ncard_le (Set.subset_univ _) ?_
rw [Subgroup.coe_top, Set.ncard_univ, ← Nat.card_coe_set_eq, SetLike.coe_sort_coe,
← Nat.card_congr (QuotientGroup.quotientKerEquivRange f).toEquiv]
exact Nat.le_of_mul_le_mul_left (f.ker.card_mul_index ▸ Nat.mul_le_of_... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Ring.GeomSum | {
"line": 121,
"column": 4
} | {
"line": 121,
"column": 67
} | [
{
"pp": "case refine_1\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\nn : ℕ\nx : R\nhn✝ : n ≠ 0\nh : 0 < ∑ i ∈ range n, x ^ i\nhn : Even n\nhx : x + 1 ≤ 0\n⊢ ∑ i ∈ range n, x ^ i ≤ 0",
"usedConstants": [
"geom_sum_alternating_of_le_neg_one",
"Ring.toNonAss... | simpa [if_pos hn] using geom_sum_alternating_of_le_neg_one hx n | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Data.ZMod.Basic | {
"line": 440,
"column": 31
} | {
"line": 443,
"column": 86
} | [
{
"pp": "n✝ : ℕ\nR : Type u_1\ninst✝¹ : Ring R\ninst✝ : CharP R n✝\nm n : ℕ\nh : m + 1 = n + 1\na b : ZMod (m + 1)\n⊢ (finCongr h).toFun (a * b) = (finCongr h).toFun a * (finCongr h).toFun b",
"usedConstants": [
"Eq.mpr",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
... | by
dsimp [ZMod]
ext
rw [Fin.val_cast, Fin.val_mul, Fin.val_mul, Fin.val_cast, Fin.val_cast, ← h] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.NumberTheory.Divisors | {
"line": 125,
"column": 2
} | {
"line": 134,
"column": 69
} | [
{
"pp": "n : ℕ\nx : ℕ × ℕ\n⊢ x ∈ n.divisorsAntidiagonal ↔ x.1 * x.2 = n ∧ n ≠ 0",
"usedConstants": [
"Eq.mpr",
"False",
"Nat.instMulZeroClass",
"IsDomain.to_noZeroDivisors",
"Dvd.dvd",
"instHDiv",
"_private.Mathlib.NumberTheory.Divisors.0.Nat.mem_divisorsAntidiagona... | obtain ⟨a, b⟩ := x
simp only [divisorsAntidiagonal, mul_div_eq_iff_dvd, mem_filterMap, mem_Icc, one_le_iff_ne_zero,
Option.ite_none_right_eq_some, Option.some.injEq, Prod.ext_iff, and_left_comm, exists_eq_left]
constructor
· rintro ⟨han, ⟨ha, han'⟩, rfl⟩
simp [Nat.mul_div_eq_iff_dvd, han]
lia
· rint... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Divisors | {
"line": 125,
"column": 2
} | {
"line": 134,
"column": 69
} | [
{
"pp": "n : ℕ\nx : ℕ × ℕ\n⊢ x ∈ n.divisorsAntidiagonal ↔ x.1 * x.2 = n ∧ n ≠ 0",
"usedConstants": [
"Eq.mpr",
"False",
"Nat.instMulZeroClass",
"IsDomain.to_noZeroDivisors",
"Dvd.dvd",
"instHDiv",
"_private.Mathlib.NumberTheory.Divisors.0.Nat.mem_divisorsAntidiagona... | obtain ⟨a, b⟩ := x
simp only [divisorsAntidiagonal, mul_div_eq_iff_dvd, mem_filterMap, mem_Icc, one_le_iff_ne_zero,
Option.ite_none_right_eq_some, Option.some.injEq, Prod.ext_iff, and_left_comm, exists_eq_left]
constructor
· rintro ⟨han, ⟨ha, han'⟩, rfl⟩
simp [Nat.mul_div_eq_iff_dvd, han]
lia
· rint... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Divisors | {
"line": 149,
"column": 2
} | {
"line": 149,
"column": 31
} | [
{
"pp": "n a b : ℕ\nc : a < b\nd : ℕ × ℕ\nh : a * (n / a) = n ∧ (a, n / a) = d\nha : ℕ × ℕ\nh' : b * (n / b) = n ∧ (b, n / b) = ha\n⊢ d.1 < ha.1",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"congrArg",
"id",
"HDiv.hDiv",
"Prod.mk",
"instMulNat",
... | simpa [← h.right, ← h'.right] | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.NumberTheory.Divisors | {
"line": 404,
"column": 2
} | {
"line": 407,
"column": 28
} | [
{
"pp": "n : ℕ\nh : 0 < n\n⊢ n.Perfect ↔ ∑ i ∈ n.divisors, i = 2 * n",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.perfect_iff_sum_properDivisors",
"Nat.instIsOrderedAddMonoid",
"HMul.hMul",
"congrArg",
"instIsLeftCancelAddOfAddLeftR... | rw [perfect_iff_sum_properDivisors h, sum_divisors_eq_sum_properDivisors_add_self, two_mul]
constructor <;> intro h
· rw [h]
· apply add_right_cancel h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Divisors | {
"line": 404,
"column": 2
} | {
"line": 407,
"column": 28
} | [
{
"pp": "n : ℕ\nh : 0 < n\n⊢ n.Perfect ↔ ∑ i ∈ n.divisors, i = 2 * n",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.perfect_iff_sum_properDivisors",
"Nat.instIsOrderedAddMonoid",
"HMul.hMul",
"congrArg",
"instIsLeftCancelAddOfAddLeftR... | rw [perfect_iff_sum_properDivisors h, sum_divisors_eq_sum_properDivisors_add_self, two_mul]
constructor <;> intro h
· rw [h]
· apply add_right_cancel h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Digits.Defs | {
"line": 122,
"column": 80
} | {
"line": 125,
"column": 78
} | [
{
"pp": "b x : ℕ\nhx : x ≠ 0\nhxb : x < b\n⊢ b.digits x = [x]",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"congrArg",
"Nat.le_add_left",
"Nat.digits_add_two_add_one",
"Exists",
"id",
"HDiv.hDiv",
"Nat.instMod",
"instHMod",
"Ne",
"instOfN... | by
rcases exists_eq_succ_of_ne_zero hx with ⟨x, rfl⟩
rcases Nat.exists_eq_add_of_le' ((Nat.le_add_left 1 x).trans_lt hxb) with ⟨b, rfl⟩
rw [digits_add_two_add_one, div_eq_of_lt hxb, digits_zero, mod_eq_of_lt hxb] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.NumberTheory.Divisors | {
"line": 508,
"column": 69
} | {
"line": 519,
"column": 27
} | [
{
"pp": "p : ℕ\npp : Prime p\nk x : ℕ\n⊢ x ∈ (p ^ k).properDivisors ↔ ∃ j, ∃ (_ : j < k), x = p ^ j",
"usedConstants": [
"instPowNat",
"Eq.mpr",
"Dvd.dvd",
"_private.Mathlib.NumberTheory.Divisors.0.Nat.mem_properDivisors_prime_pow._simp_1_3",
"Nat.Prime.one_lt",
"congrArg... | by
rw [mem_properDivisors, Nat.dvd_prime_pow pp, ← exists_and_right]
simp only [exists_prop, and_assoc]
apply exists_congr
intro a
constructor <;> intro h
· rcases h with ⟨_h_left, rfl, h_right⟩
rw [Nat.pow_lt_pow_iff_right pp.one_lt] at h_right
exact ⟨h_right, rfl⟩
· rcases h with ⟨h_left, rfl⟩
... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 161,
"column": 2
} | {
"line": 161,
"column": 68
} | [
{
"pp": "case inl\nk n : ℕ\nhn : n ≠ 0\nhp : 0 ≠ 1\n⊢ 0 ^ k ∣ n ↔ k ≤ padicValNat 0 n",
"usedConstants": [
"instPowNat",
"False",
"Dvd.dvd",
"Lean.Grind.instIsPreorderNat",
"eq_false",
"congrArg",
"Std.instReflLeOfIsPreorder",
"Std.le_refl._simp_1",
"Nat... | · rcases k.eq_zero_or_pos with rfl | hk <;> simp [Nat.ne_of_gt, *] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 60,
"column": 4
} | {
"line": 60,
"column": 62
} | [
{
"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": [
"instHDiv",
"HDiv.hDiv",
"Nat.div_lt_self",
"Nat.pos_of_ne_zero",
"Nat",
"L... | have : n / b < n := div_lt_self (Nat.pos_of_ne_zero hn) hb | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 136,
"column": 6
} | {
"line": 136,
"column": 39
} | [
{
"pp": "b : ℕ\nl : List ℕ\nhl : l ≠ []\nhl2 : l.getLast hl ≠ 0\n⊢ (b + 2) ^ l.length ≤ (b + 2) * ofDigits (b + 2) l",
"usedConstants": [
"List.getLast",
"Eq.mpr",
"HMul.hMul",
"congrArg",
"Nat.instMonoid",
"Nat.ofDigits",
"id",
"List.dropLast",
"instMul... | ← List.dropLast_append_getLast hl | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 465,
"column": 2
} | {
"line": 465,
"column": 23
} | [
{
"pp": "b : ℕ\nhb : 1 < b\nl d : ℕ\nw✝ : List ℕ\nleft✝ : w✝ ∈ fixedLengthDigits hb l\nhL : d :: w✝ ∈ consFixedLengthDigits hb l d\n⊢ d :: w✝ ≠ []",
"usedConstants": [
"Nat",
"List.cons_ne_nil"
]
}
] | exact cons_ne_nil d _ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 507,
"column": 4
} | {
"line": 507,
"column": 79
} | [
{
"pp": "case h.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⊢ ∃ a < b, ∃ a_1 ∈ fixedLengthDigits hb l, a :: a_1 = L",
"usedConstants": [
"List.head",
"List.cons_head_tail",
"List.head_mem... | refine ⟨L.head hL₃, hL₂ _ (L.head_mem hL₃), L.tail, ?_, cons_head_tail hL₃⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 76,
"column": 2
} | {
"line": 77,
"column": 6
} | [
{
"pp": "n p k : ℕ\nhn : n ≠ 0\nh : n.factorization = single p k\n⊢ n = p ^ k",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Nat.instMulZeroClass",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instMonoid",
"id",
"pow_zero",
"Monoid.toPow",
"MulOneClas... | rw [← Nat.prod_factorization_pow_eq_self hn, h]
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 76,
"column": 2
} | {
"line": 77,
"column": 6
} | [
{
"pp": "n p k : ℕ\nhn : n ≠ 0\nh : n.factorization = single p k\n⊢ n = p ^ k",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Nat.instMulZeroClass",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instMonoid",
"id",
"pow_zero",
"Monoid.toPow",
"MulOneClas... | rw [← Nat.prod_factorization_pow_eq_self hn, h]
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Multiplicity | {
"line": 558,
"column": 2
} | {
"line": 558,
"column": 99
} | [
{
"pp": "α : Type u_1\ninst✝ : Ring α\np a b : α\nh : emultiplicity p b < emultiplicity p a\n⊢ emultiplicity p (a + b) = emultiplicity p b",
"usedConstants": [
"Iff.mpr",
"False",
"instTopENat",
"congrArg",
"False.elim",
"finiteMultiplicity_iff_emultiplicity_ne_top",
... | have : FiniteMultiplicity p b := finiteMultiplicity_iff_emultiplicity_ne_top.2 (by simp [·] at h) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.Multiplicity | {
"line": 667,
"column": 6
} | {
"line": 667,
"column": 49
} | [
{
"pp": "case pos.inl\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : IsCancelMulZero α\na : α\nha : FiniteMultiplicity a a\nv : α\nhv : 1 = a * v\n⊢ False",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"IsUnit.of_m... | have : IsUnit a := .of_mul_eq_one v hv.symm | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Nat.Choose.Factorization | {
"line": 224,
"column": 4
} | {
"line": 230,
"column": 52
} | [
{
"pp": "case inr.inr.inr\np n k : ℕ\nhp' : p ≠ 2\nhk : p ≤ k\nhk' : p ≤ n - k\nhn : n < 3 * p\nhp : Prime p\nhkn : k ≤ n\ni : ℕ\nhi₁ : 1 ≤ i\nhi✝ : i < log p n + 1\nhi : 1 < i\n⊢ k % p ^ i + (n - k) % p ^ i < p ^ i",
"usedConstants": [
"Trans.trans",
"IsOrderedRing.toPosMulMono",
"HMul.hM... | replace hn : n < p ^ i := by
have : 3 ≤ p := lt_of_le_of_ne hp.two_le hp'.symm
calc
n < 3 * p := hn
_ ≤ p * p := by gcongr
_ = p ^ 2 := (sq p).symm
_ ≤ p ^ i := pow_right_mono₀ hp.one_lt.le hi | Lean.Elab.Tactic.evalReplace | Lean.Parser.Tactic.replace |
Mathlib.Algebra.CharP.Lemmas | {
"line": 56,
"column": 39
} | {
"line": 56,
"column": 56
} | [
{
"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)\nhk₀ : 0 < k\nhk : k < p ^ n\n⊢ x * y * (x ^ (k - 1) * y ^ (p ^ n - k - 1)) * ↑((p ^ n).choose k / p) =\n x * y * (x ^ (k - 1) * y ^ (p ^ n - k - 1) * ↑((p ^ n)... | mul_assoc (x * y) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Multiplicity | {
"line": 240,
"column": 6
} | {
"line": 243,
"column": 23
} | [
{
"pp": "p n k : ℕ\nhp : Prime p\nhkn : k ≤ p ^ n\nhk0 : k ≠ 0\nhdisj : Disjoint ({i ∈ Ico 1 n.succ | p ^ i ≤ k % p ^ i + (p ^ n - k) % p ^ i}) ({i ∈ Ico 1 n.succ | p ^ i ∣ k})\n⊢ emultiplicity p ((p ^ n).choose k) + emultiplicity p k ≤ ↑n",
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"Nat.cho... | rw [emultiplicity_choose hp hkn (lt_succ_self _),
emultiplicity_eq_card_pow_dvd (ne_of_gt hp.one_lt) hk0.bot_lt
(lt_succ_of_le (log_mono_right hkn)),
← Nat.cast_add] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 537,
"column": 4
} | {
"line": 539,
"column": 38
} | [
{
"pp": "a b m n : ℕ\nhmn : m.Coprime n\nh : a ^ m = b ^ n\nha0 : ¬a = 0\nhn0 : ¬n = 0\nfactors : ℕ →₀ ℕ := mapRange (fun x ↦ x / n) ⋯ a.factorization\nc : ℕ := factors.prod fun x1 x2 ↦ x1 ^ x2\nhc : c = factors.prod fun x1 x2 ↦ x1 ^ x2\nha : a = c ^ n\n⊢ a = c ^ n ∧ b = c ^ m",
"usedConstants": [
"in... | refine ⟨ha, ?_⟩
apply Nat.pow_left_injective hn0
simp [← h, ha, Nat.pow_right_comm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 537,
"column": 4
} | {
"line": 539,
"column": 38
} | [
{
"pp": "a b m n : ℕ\nhmn : m.Coprime n\nh : a ^ m = b ^ n\nha0 : ¬a = 0\nhn0 : ¬n = 0\nfactors : ℕ →₀ ℕ := mapRange (fun x ↦ x / n) ⋯ a.factorization\nc : ℕ := factors.prod fun x1 x2 ↦ x1 ^ x2\nhc : c = factors.prod fun x1 x2 ↦ x1 ^ x2\nha : a = c ^ n\n⊢ a = c ^ n ∧ b = c ^ m",
"usedConstants": [
"in... | refine ⟨ha, ?_⟩
apply Nat.pow_left_injective hn0
simp [← h, ha, Nat.pow_right_comm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.OrderOfElement | {
"line": 227,
"column": 8
} | {
"line": 227,
"column": 19
} | [
{
"pp": "case pos\nG : Type u_1\ninst✝ : Monoid G\nx : G\nn : ℕ\nh : 0 < n\nh1 : 1 ∈ periodicPts fun x_1 ↦ x * x_1\n⊢ Nat.find h1 = n ↔ IsPeriodicPt (fun x_1 ↦ x * x_1) n 1 ∧ ∀ m < n, 0 < m → ¬IsPeriodicPt (fun x_1 ↦ x * x_1) m 1",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
... | find_eq_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.OrderOfElement | {
"line": 296,
"column": 2
} | {
"line": 296,
"column": 34
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx : G\nn a b : ℕ\nh : a ≡ b [MOD n]\nhx : x ^ n = 1\n⊢ x ^ a = x ^ b",
"usedConstants": [
"le_total",
"Nat",
"Nat.instLinearOrder"
]
}
] | obtain hle | hle := le_total a b | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.GroupTheory.OrderOfElement | {
"line": 676,
"column": 37
} | {
"line": 676,
"column": 52
} | [
{
"pp": "G : Type u_1\ninst✝ : RightCancelMonoid G\nx : G\nm✝ n m k : ℕ\nhmn : m ≤ m + k\nh : m + k ≡ m [MOD orderOf x]\nhk : x ^ k = 1\n⊢ x ^ (m + k) = x ^ m * x ^ k",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"pow_add",
"id",
"M... | by rw [pow_add] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Tactic.ComputeDegree | {
"line": 117,
"column": 4
} | {
"line": 118,
"column": 50
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝ : Semiring R\nd df dg : ℕ\na b : R\nf g : R[X]\nh_mul_left✝ : f.natDegree ≤ df\nh_mul_right✝ : g.natDegree ≤ dg\nh_mul_left : f.coeff df = a\nh_mul_right : g.coeff dg = b\nddf : df + dg ≤ d\nh : d = df + dg\n⊢ (f * g).coeff d = a * b",
"usedConstants": [
"HMul.hM... | subst h_mul_left h_mul_right h
exact coeff_mul_add_eq_of_natDegree_le ‹_› ‹_› | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.ComputeDegree | {
"line": 117,
"column": 4
} | {
"line": 118,
"column": 50
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝ : Semiring R\nd df dg : ℕ\na b : R\nf g : R[X]\nh_mul_left✝ : f.natDegree ≤ df\nh_mul_right✝ : g.natDegree ≤ dg\nh_mul_left : f.coeff df = a\nh_mul_right : g.coeff dg = b\nddf : df + dg ≤ d\nh : d = df + dg\n⊢ (f * g).coeff d = a * b",
"usedConstants": [
"HMul.hM... | subst h_mul_left h_mul_right h
exact coeff_mul_add_eq_of_natDegree_le ‹_› ‹_› | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.OrderOfElement | {
"line": 1061,
"column": 71
} | {
"line": 1061,
"column": 88
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\ng : G\nk : ℤ\n⊢ g ∈ zpowers (g ^ k) ↔ ∃ x, (g ^ k) ^ x = g",
"usedConstants": [
"_private.Mathlib.GroupTheory.OrderOfElement.0.mem_zpowers_zpow_iff._simp_1_7",
"congrArg",
"DivInvMonoid.toZPow",
"Group.toDivisionMonoid",
"Membership.mem",... | ← mem_zpowers_iff | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Polynomial.RingDivision | {
"line": 97,
"column": 8
} | {
"line": 97,
"column": 47
} | [
{
"pp": "case neg\nR : Type u\ninst✝¹ : Semiring R\ninst✝ : NoZeroDivisors R\np q : R[X]\nhp : ¬p = 0\nhq : ¬q = 0\n⊢ (p * q).trailingDegree = p.trailingDegree + q.trailingDegree",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"ENat.instNatCast",
"congrArg",
"instAddENat",
"i... | trailingDegree_eq_natTrailingDegree hp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.RingDivision | {
"line": 187,
"column": 2
} | {
"line": 194,
"column": 26
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\nhp : p.Monic\n⊢ ((-1) ^ p.natDegree * p.comp (-X)).Monic",
"usedConstants": [
"one_pow",
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Polynomial.C",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOn... | simp only [Monic]
calc
((-1) ^ p.natDegree * p.comp (-X)).leadingCoeff =
(p.comp (-X) * C ((-1) ^ p.natDegree)).leadingCoeff := by
simp [mul_comm]
_ = 1 := by
apply monic_mul_C_of_leadingCoeff_mul_eq_one
simp [← pow_add, hp] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.RingDivision | {
"line": 187,
"column": 2
} | {
"line": 194,
"column": 26
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\nhp : p.Monic\n⊢ ((-1) ^ p.natDegree * p.comp (-X)).Monic",
"usedConstants": [
"one_pow",
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Polynomial.C",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOn... | simp only [Monic]
calc
((-1) ^ p.natDegree * p.comp (-X)).leadingCoeff =
(p.comp (-X) * C ((-1) ^ p.natDegree)).leadingCoeff := by
simp [mul_comm]
_ = 1 := by
apply monic_mul_C_of_leadingCoeff_mul_eq_one
simp [← pow_add, hp] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Expand | {
"line": 78,
"column": 38
} | {
"line": 78,
"column": 54
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nf : R[X]\nr : R\n⊢ (expand R 1) (C r) = C r",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"congrArg",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"Polynomial.algebraOfAlgebra",
"Polynomial.expand_C",
... | by rw [expand_C] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Expand | {
"line": 148,
"column": 6
} | {
"line": 148,
"column": 37
} | [
{
"pp": "case pos\nR : Type u\ninst✝ : CommSemiring R\np : ℕ\nf : R[X]\nhp : p > 0\nhf : ¬f = 0\nhf1 : (expand R p) f ≠ 0\nn : ℕ\nhpn : p ∣ n\nhn : n / p ≤ f.natDegree\n⊢ n / p * p ≤ f.natDegree * p",
"usedConstants": [
"instHDiv",
"CommSemiring.toSemiring",
"Nat.mul_le_mul_right",
"... | exact Nat.mul_le_mul_right p hn | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Polynomial.Div | {
"line": 178,
"column": 4
} | {
"line": 178,
"column": 65
} | [
{
"pp": "case neg\nR : Type u\ninst✝ : Ring R\np q : R[X]\nhmq : q.Monic\nhq : q ≠ 1\nhpq : ¬p %ₘ q = 0\nthis : Nontrivial R\n⊢ (p %ₘ q).natDegree < q.natDegree",
"usedConstants": [
"Polynomial.modByMonic",
"Polynomial.degree_modByMonic_lt",
"Polynomial.natDegree_lt_natDegree",
"Ring... | exact natDegree_lt_natDegree hpq (degree_modByMonic_lt p hmq) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Polynomial.Div | {
"line": 243,
"column": 46
} | {
"line": 251,
"column": 87
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\np q : R[X]\nthis : DecidableEq R := Classical.decEq R\nhq : q.Monic\nh : q.degree ≤ p.degree ∧ p ≠ 0\n⊢ p %ₘ q = p - q * (p /ₘ q)",
"usedConstants": [
"Polynomial.modByMonic.eq_1",
"Distrib.leftDistribClass",
"WithBot.instPreorder",
"Eq.mpr",
... | by
have _wf := div_wf_lemma h hq
have ih := modByMonic_eq_sub_mul_div
(p - q * (C (leadingCoeff p) * X ^ (natDegree p - natDegree q))) q
unfold modByMonic divByMonic divModByMonicAux
rw [dif_pos hq, dif_pos h]
rw [modByMonic, dif_pos hq] at ih
refine ih.trans ?_... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Div | {
"line": 321,
"column": 7
} | {
"line": 322,
"column": 88
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\np q : R[X]\nhp0 : p ≠ 0\nh0q : 0 < q.degree\nthis : DecidableEq R := Classical.decEq R\nhq : ¬q.Monic\n⊢ (p /ₘ q).degree < p.degree",
"usedConstants": [
"WithBot.instPreorder",
"Eq.mpr",
"Polynomial.divByMonic_eq_of_not_monic",
"WithBot",
"P... | by
rwa [divByMonic_eq_of_not_monic _ hq, degree_zero, bot_lt_iff_ne_bot, degree_ne_bot] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Div | {
"line": 351,
"column": 2
} | {
"line": 351,
"column": 75
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\nf g q r : R[X]\nhg : g.Monic\nh : r + g * q = f ∧ r.degree < g.degree\na✝ : Nontrivial R\nh₁ : r - f %ₘ g = -g * (q - f /ₘ g)\n⊢ f /ₘ g = q ∧ f %ₘ g = r",
"usedConstants": [
"WithBot",
"Polynomial.instNeg",
"HMul.hMul",
"Ring.toNonAssocRing",
... | have h₂ : degree (r - f %ₘ g) = degree (g * (q - f /ₘ g)) := by simp [h₁] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Polynomial.Div | {
"line": 470,
"column": 4
} | {
"line": 470,
"column": 68
} | [
{
"pp": "case pos\nR : Type u\ninst✝ : Ring R\np : R[X]\na : R\nn : ℕ\nh : p.natDegree ≤ n\na✝ : Nontrivial R\nhp : p.natDegree = 0\n⊢ (p /ₘ (X - C a)).coeff n = 0",
"usedConstants": [
"Iff.mpr",
"Polynomial.monic_X_sub_C",
"WithBot.instPreorder",
"Eq.mpr",
"Polynomial.C",
... | rw [(divByMonic_eq_zero_iff <| monic_X_sub_C a).mpr, coeff_zero] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Polynomial.Div | {
"line": 578,
"column": 4
} | {
"line": 579,
"column": 43
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\na : R\na✝ : Nontrivial R\n⊢ eval a (p %ₘ (X - C a)) = eval a p",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Polynomial.eval",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing"... | rw [modByMonic_eq_sub_mul_div, eval_sub, eval_mul, eval_sub, eval_X,
eval_C, sub_self, zero_mul, sub_zero] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 499,
"column": 51
} | {
"line": 499,
"column": 63
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nn k : ℕ\n⊢ ↑(n.descFactorial k) * X ^ (n - k) = C ↑(n.descFactorial k) * X ^ (n - k)",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
... | C_eq_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.BigOperators.Associated | {
"line": 224,
"column": 48
} | {
"line": 225,
"column": 87
} | [
{
"pp": "M₀ : Type u_3\nM : Type u_4\ninst✝ : CommMonoidWithZero M\nS : Finset M₀\np : M\npp : Prime p\ng : M₀ → M\nhS : ∀ a ∈ S, ¬p ∣ g a\n⊢ ¬p ∣ S.prod g",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Iff.mpr",
"Dvd.dvd",
"Finset",
"semigroupDvd",
"Membership.... | by
exact mt (Prime.dvd_finset_prod_iff pp _).1 <| not_exists.2 fun a => not_and.2 (hS a) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 754,
"column": 19
} | {
"line": 754,
"column": 31
} | [
{
"pp": "R : Type u\ninst✝² : CommSemiring R\ninst✝¹ : NoZeroDivisors R\nn : ℕ\nchn : C ↑n ≠ 0\na : R[X]\ninst✝ : Nontrivial R\n⊢ derivative (a ^ n) = 0 ↔ derivative a = 0",
"usedConstants": [
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithOne",
"congrArg",
"CommSemiring.toSemi... | C_eq_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.UniqueFactorizationDomain.Basic | {
"line": 290,
"column": 2
} | {
"line": 297,
"column": 60
} | [
{
"pp": "α : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\np q : Multiset (Associates α)\n⊢ (∀ a ∈ p, Irreducible a) → (∀ a ∈ q, Irreducible a) → p.prod = q.prod → p = q",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Associates.mk",
"Associates.mk_... | apply Multiset.induction_on_multiset_quot p
apply Multiset.induction_on_multiset_quot q
intro s t hs ht eq
refine Multiset.map_mk_eq_map_mk_of_rel (UniqueFactorizationMonoid.factors_unique ?_ ?_ ?_)
· exact fun a ha => irreducible_mk.1 <| hs _ <| Multiset.mem_map_of_mem _ ha
· exact fun a ha => irreducible_mk... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.UniqueFactorizationDomain.Basic | {
"line": 290,
"column": 2
} | {
"line": 297,
"column": 60
} | [
{
"pp": "α : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\np q : Multiset (Associates α)\n⊢ (∀ a ∈ p, Irreducible a) → (∀ a ∈ q, Irreducible a) → p.prod = q.prod → p = q",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Associates.mk",
"Associates.mk_... | apply Multiset.induction_on_multiset_quot p
apply Multiset.induction_on_multiset_quot q
intro s t hs ht eq
refine Multiset.map_mk_eq_map_mk_of_rel (UniqueFactorizationMonoid.factors_unique ?_ ?_ ?_)
· exact fun a ha => irreducible_mk.1 <| hs _ <| Multiset.mem_map_of_mem _ ha
· exact fun a ha => irreducible_mk... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 306,
"column": 2
} | {
"line": 306,
"column": 34
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\nx : α\nhx : IsUnit x\n⊢ normalizedFactors x = 0",
"usedConstants": [
"CommMonoidWithZero.toMonoidWithZero",
"MonoidWithZero.toMulZeroOneClass",
"eq_or_ne",
"Zero... | obtain rfl | hx₀ := eq_or_ne x 0 | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 403,
"column": 6
} | {
"line": 403,
"column": 37
} | [
{
"pp": "case neg\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\nx : Associates α\nhx : ¬x = 0\nh : ⇑Associates.mkMonoidHom ∘ Classical.choose ⋯ = id\n⊢ failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation)",
"usedConstants": [
... | apply prod_normalizedFactors hx | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.