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": 503,
"column": 2
} | {
"line": 504,
"column": 16
} | [
{
"pp": "R : Type u\nσ : Type u_1\ninst✝ : CommSemiring R\np : MvPolynomial (Option σ) R\nm : ℕ\nd : σ →₀ ℕ\n⊢ coeff d (((optionEquivLeft R σ) p).coeff m) = coeff (optionElim m d) p",
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiri... | rw [← optionEquivLeft_coeff_some_coeff_none]
congr <;> simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.MvPolynomial.Equiv | {
"line": 503,
"column": 2
} | {
"line": 504,
"column": 16
} | [
{
"pp": "R : Type u\nσ : Type u_1\ninst✝ : CommSemiring R\np : MvPolynomial (Option σ) R\nm : ℕ\nd : σ →₀ ℕ\n⊢ coeff d (((optionEquivLeft R σ) p).coeff m) = coeff (optionElim m d) p",
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiri... | rw [← optionEquivLeft_coeff_some_coeff_none]
congr <;> simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.EraseLead | {
"line": 393,
"column": 44
} | {
"line": 393,
"column": 61
} | [
{
"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⊢ ∀ (a : ℕ), (∑ i, C (x i) * X ^ k i).coeff a ≠ 0 ↔ a ∈ image k univ",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"HMul.hMul",
"Finset.univ",
... | finset_sum_coeff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Polynomial.EraseLead | {
"line": 428,
"column": 10
} | {
"line": 428,
"column": 40
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝ : Semiring R\nn : ℕ\nhn : ∀ {f : R[X]}, #f.support = n → ∃ k x, ∃ (_ : StrictMono k) (_ : ∀ (i : Fin n), x i ≠ 0), f = ∑ i, C (x i) * X ^ k i\nf : R[X]\nh : #f.support = n + 1\nk : Fin n → ℕ\nx : Fin n → R\nhk : StrictMono k\nhx : ∀ (i : Fin n), x i ≠ 0\nhf : f.eraseLead =... | ← Fin.castSucc_lt_castSucc_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Monic | {
"line": 576,
"column": 4
} | {
"line": 581,
"column": 8
} | [
{
"pp": "case mp\nR : Type u\ninst✝ : Semiring R\np : R[X]\nh : IsUnit p.leadingCoeff\nq : R[X]\n⊢ q * p = 0 → q = 0",
"usedConstants": [
"Units.val",
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"IsUnit.... | intro hp
replace hp := congr_arg (· * C ↑h.unit⁻¹) hp
simp only [zero_mul] at hp
rwa [mul_assoc, Monic.mul_left_eq_zero_iff] at hp
refine monic_mul_C_of_leadingCoeff_mul_eq_one ?_
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Monic | {
"line": 576,
"column": 4
} | {
"line": 581,
"column": 8
} | [
{
"pp": "case mp\nR : Type u\ninst✝ : Semiring R\np : R[X]\nh : IsUnit p.leadingCoeff\nq : R[X]\n⊢ q * p = 0 → q = 0",
"usedConstants": [
"Units.val",
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"IsUnit.... | intro hp
replace hp := congr_arg (· * C ↑h.unit⁻¹) hp
simp only [zero_mul] at hp
rwa [mul_assoc, Monic.mul_left_eq_zero_iff] at hp
refine monic_mul_C_of_leadingCoeff_mul_eq_one ?_
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.BigOperators | {
"line": 288,
"column": 89
} | {
"line": 303,
"column": 79
} | [
{
"pp": "R : Type u\nι : Type w\ns : Finset ι\ninst✝² : CommRing R\nA : Type u_1\ninst✝¹ : CommRing A\ninst✝ : Algebra R A\nf : ι → R[X]\nv : ι → A\nh : LinearIndepOn R v ↑s\n⊢ (∑ i ∈ s, v i • map (algebraMap R A) (f i)).degree = s.sup fun i ↦ (f i).degree",
"usedConstants": [
"Polynomial.degree_map_l... | by
apply le_antisymm
· exact (degree_sum_le s _).trans <| Finset.sup_le fun i hi ↦ (degree_smul_le _ _).trans <|
degree_map_le.trans <| Finset.le_sup (f := fun i ↦ (f i).degree) hi
· apply Finset.sup_le
intro i hi
by_cases hf : f i = 0
· simp [hf]
rw [degree_eq_natDegree hf]
apply le_deg... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Adjoin.FG | {
"line": 54,
"column": 8
} | {
"line": 54,
"column": 18
} | [
{
"pp": "R : Type u\nA : Type v\ninst✝² : CommSemiring R\ninst✝¹ : CommSemiring A\ninst✝ : Algebra R A\ns t : Set A\nh1 : (Subalgebra.toSubmodule (adjoin R s)).FG\nh2 : (Subalgebra.toSubmodule (adjoin (↥(adjoin R s)) t)).FG\np : Set A\nhp : p.Finite\nhp' : span R p = Subalgebra.toSubmodule (adjoin R s)\nq : Set... | rw [← hp'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Ring.GeomSum | {
"line": 242,
"column": 15
} | {
"line": 242,
"column": 25
} | [
{
"pp": "R : Type u_1\ninst✝ : Ring R\nx : R\nn : ℕ\nthis : -((∑ i ∈ range n, x ^ i) * (x - 1)) = 1 - x ^ n\n⊢ (∑ i ∈ range n, x ^ i) * (1 - x) = 1 - x ^ n",
"usedConstants": [
"HMul.hMul",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
"congrArg",
"AddGroupWithOne.toAddM... | ← mul_neg, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.EraseLead | {
"line": 474,
"column": 2
} | {
"line": 479,
"column": 7
} | [
{
"pp": "case refine_1\nR : Type u_1\ninst✝ : Semiring R\nf : R[X]\nh : #f.support = 3\n⊢ ∃ k m n,\n ∃ (_ : k < m) (_ : m < n),\n ∃ x y z, ∃ (_ : x ≠ 0) (_ : y ≠ 0) (_ : z ≠ 0), f = C x * X ^ k + C y * X ^ m + C z * X ^ n",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Fin.sum_univ... | · obtain ⟨k, x, hk, hx, rfl⟩ := card_support_eq.mp h
refine
⟨k 0, k 1, k 2, hk Nat.zero_lt_one, hk (Nat.lt_succ_self 1), x 0, x 1, x 2, hx 0, hx 1, hx 2,
?_⟩
rw [Fin.sum_univ_castSucc, Fin.sum_univ_castSucc, Fin.sum_univ_one]
rfl | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.Adjoin.Tower | {
"line": 40,
"column": 4
} | {
"line": 42,
"column": 13
} | [
{
"pp": "C : Type u_1\nD : Type u_2\nE : Type u_3\ninst✝⁶ : CommSemiring C\ninst✝⁵ : CommSemiring D\ninst✝⁴ : CommSemiring E\ninst✝³ : Algebra C D\ninst✝² : Algebra C E\ninst✝¹ : Algebra D E\ninst✝ : IsScalarTower C D E\nS : Set E\nthis : Set.range ⇑(algebraMap D E) = Set.range ⇑(algebraMap (↥(Subalgebra.map (I... | ext x
change x ∈ Subsemiring.closure (_ ∪ S) ↔ x ∈ Subsemiring.closure (_ ∪ S)
rw [this] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Adjoin.Tower | {
"line": 40,
"column": 4
} | {
"line": 42,
"column": 13
} | [
{
"pp": "C : Type u_1\nD : Type u_2\nE : Type u_3\ninst✝⁶ : CommSemiring C\ninst✝⁵ : CommSemiring D\ninst✝⁴ : CommSemiring E\ninst✝³ : Algebra C D\ninst✝² : Algebra C E\ninst✝¹ : Algebra D E\ninst✝ : IsScalarTower C D E\nS : Set E\nthis : Set.range ⇑(algebraMap D E) = Set.range ⇑(algebraMap (↥(Subalgebra.map (I... | ext x
change x ∈ Subsemiring.closure (_ ∪ S) ↔ x ∈ Subsemiring.closure (_ ∪ S)
rw [this] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 197,
"column": 17
} | {
"line": 197,
"column": 28
} | [
{
"pp": "case pos\nR : Type u\ninst✝ : Semiring R\ns : Set R[X]\np : R[X]\nhs : s.Nonempty\nhp : p ∈ Submodule.span R s\nh : ∀ p' ∈ s, p'.degree < degree 0\nhp_zero : p = 0\n⊢ False",
"usedConstants": [
"WithBot",
"Preorder.toLT",
"congrArg",
"PartialOrder.toPreorder",
"Members... | degree_zero | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 220,
"column": 2
} | {
"line": 220,
"column": 29
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\ns : Set R[X]\ns_fin : s.Finite\n⊢ ∃ n, Submodule.span R s ≤ degreeLE R ↑n",
"usedConstants": [
"Submodule",
"WithBot",
"Semiring.toModule",
"PartialOrder.toPreorder",
"Polynomial.degreeLE",
"Classical.propDecidable",
"Preorde... | by_cases s_emp : s.Nonempty | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 348,
"column": 80
} | {
"line": 348,
"column": 97
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\ni : ℕ\n⊢ (if i = 0 then 1 else 0) = ↑(if i = 0 then 1 else 0)",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Polynomial.instOne",
"Subring.instSetLike",
"Ring.toNonAssocRing",
"congrArg",
"Finset",
... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.Algebra.Subalgebra.Operations | {
"line": 69,
"column": 2
} | {
"line": 69,
"column": 61
} | [
{
"pp": "case H\nR : Type u_1\nS : Type u_2\ninst✝² : CommSemiring R\ninst✝¹ : CommSemiring S\ninst✝ : Algebra R S\nS' : Subalgebra R S\nι : Type u_3\nι' : Finset ι\ns l : ι → S\ne : ∑ i ∈ ι', l i * s i = 1\nhs : ∀ (i : ι), s i ∈ S'\nhl : ∀ (i : ι), l i ∈ S'\nx : S\nn : ι → ℕ\nhn : ∀ (i : ι), s i ^ n i • x ∈ S'... | refine Submodule.smul_mem _ (⟨_, pow_mem (hs i) _⟩ : S') ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.RingTheory.FiniteType | {
"line": 332,
"column": 79
} | {
"line": 337,
"column": 21
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝¹ : CommSemiring R\ninst✝ : AddMonoid M\nf : R[M]\n⊢ f ∈ adjoin R (of' R M '' ↑f.support)",
"usedConstants": [
"Eq.mpr",
"Submodule",
"AddMonoidAlgebra.semiring",
"Semiring.toModule",
"AddMonoidAlgebra.addAddCommMonoid",
"congrArg... | by
suffices span R (of' R M '' f.support) ≤
Subalgebra.toSubmodule (adjoin R (of' R M '' f.support)) by
exact this (mem_span_support f)
rw [Submodule.span_le]
exact subset_adjoin | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.FiniteType | {
"line": 443,
"column": 2
} | {
"line": 446,
"column": 52
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝¹ : AddMonoid M\ninst✝ : CommRing R\nh : AddMonoid.FG M\n⊢ FiniteType R R[M]",
"usedConstants": [
"Algebra.FiniteType.of_surjective",
"AddMonoidAlgebra.semiring",
"AddSubmonoid.instTop",
"Equiv.instEquivLike",
"FreeAlgebra.instSemiring"... | obtain ⟨S, hS⟩ := h.fg_top
exact .of_surjective
(FreeAlgebra.lift R fun s : (S : Set M) => of' R M ↑s)
(freeAlgebra_lift_of_surjective_of_closure hS) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.FiniteType | {
"line": 443,
"column": 2
} | {
"line": 446,
"column": 52
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝¹ : AddMonoid M\ninst✝ : CommRing R\nh : AddMonoid.FG M\n⊢ FiniteType R R[M]",
"usedConstants": [
"Algebra.FiniteType.of_surjective",
"AddMonoidAlgebra.semiring",
"AddSubmonoid.instTop",
"Equiv.instEquivLike",
"FreeAlgebra.instSemiring"... | obtain ⟨S, hS⟩ := h.fg_top
exact .of_surjective
(FreeAlgebra.lift R fun s : (S : Set M) => of' R M ↑s)
(freeAlgebra_lift_of_surjective_of_closure hS) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.FiniteType | {
"line": 679,
"column": 2
} | {
"line": 688,
"column": 59
} | [
{
"pp": "case refine_2\nR : Type u_1\ninst✝ : CommRing R\nM : Type u_1\nx✝² : AddCommMonoid M\nx✝¹ : Module R M\nx✝ : Module.Finite R M\nN : Submodule R M\nf : ↥N →ₗ[R] M\nhf : Surjective ⇑f\nthis✝² : AddCommGroup M := addCommMonoidToAddCommGroup R\nthis✝¹ : AddCommGroup ↥N := addCommMonoidToAddCommGroup R\ni :... | · induction hx using span_induction with
| mem x hx =>
change f x ∈ M'
simp only [Set.singleton_union, Set.mem_insert_iff, Set.mem_range] at hx
rcases hx with hx | ⟨j, rfl⟩
· rw [hx, hn]; exact zero_mem _
· exact subset_span (by simp [hnj])
| zero => simp
| add x _ y _ hx hy =>... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Int.ModEq | {
"line": 250,
"column": 2
} | {
"line": 250,
"column": 43
} | [
{
"pp": "n a b : ℤ\nh : a ≡ b [ZMOD n]\n⊢ a ≡ 0 [ZMOD n] ↔ b ≡ 0 [ZMOD n]",
"usedConstants": [
"Int.ModEq.symm",
"Int.ModEq.trans",
"Int",
"instOfNat",
"Int.ModEq",
"Iff.intro",
"OfNat.ofNat"
]
}
] | exact ⟨fun ha ↦ h.symm.trans ha, h.trans⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Algebra.Subalgebra.Unitization | {
"line": 142,
"column": 6
} | {
"line": 145,
"column": 24
} | [
{
"pp": "case refine_1\nR : Type u_1\nS : Type u_2\nA : Type u_3\ninst✝³ : Field R\ninst✝² : Ring A\ninst✝¹ : Algebra R A\ninst✝ : SetLike S A\nhSA : NonUnitalSubringClass S A\nhSRA : SMulMemClass S R A\ns : S\nh1 : 1 ∉ s\nalgHom : Unitization R ↥s →ₐ[R] ↥(Algebra.adjoin R ↑s) := (unitization s).codRestrict (Al... | have := AlgHomClass.unitization_injective s h1
((Subalgebra.val _).comp algHom) fun _ ↦ by simp [algHom]
rw [AlgHom.coe_comp] at this
exact this.of_comp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Algebra.Subalgebra.Unitization | {
"line": 142,
"column": 6
} | {
"line": 145,
"column": 24
} | [
{
"pp": "case refine_1\nR : Type u_1\nS : Type u_2\nA : Type u_3\ninst✝³ : Field R\ninst✝² : Ring A\ninst✝¹ : Algebra R A\ninst✝ : SetLike S A\nhSA : NonUnitalSubringClass S A\nhSRA : SMulMemClass S R A\ns : S\nh1 : 1 ∉ s\nalgHom : Unitization R ↥s →ₐ[R] ↥(Algebra.adjoin R ↑s) := (unitization s).codRestrict (Al... | have := AlgHomClass.unitization_injective s h1
((Subalgebra.val _).comp algHom) fun _ ↦ by simp [algHom]
rw [AlgHom.coe_comp] at this
exact this.of_comp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GCDMonoid.Nat | {
"line": 135,
"column": 57
} | {
"line": 135,
"column": 73
} | [
{
"pp": "i j : ℤ\n⊢ 0 ≤ GCDMonoid.lcm i j",
"usedConstants": [
"Int.lcm",
"Int.natCast_nonneg._simp_1",
"Int",
"LE.le",
"Nat.cast",
"instOfNat",
"of_eq_true",
"instNatCastInt",
"OfNat.ofNat",
"Int.instLEInt"
]
}
] | simp [← coe_lcm] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.GCDMonoid.Nat | {
"line": 135,
"column": 57
} | {
"line": 135,
"column": 73
} | [
{
"pp": "i j : ℤ\n⊢ 0 ≤ GCDMonoid.lcm i j",
"usedConstants": [
"Int.lcm",
"Int.natCast_nonneg._simp_1",
"Int",
"LE.le",
"Nat.cast",
"instOfNat",
"of_eq_true",
"instNatCastInt",
"OfNat.ofNat",
"Int.instLEInt"
]
}
] | simp [← coe_lcm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.GCDMonoid.Nat | {
"line": 135,
"column": 57
} | {
"line": 135,
"column": 73
} | [
{
"pp": "i j : ℤ\n⊢ 0 ≤ GCDMonoid.lcm i j",
"usedConstants": [
"Int.lcm",
"Int.natCast_nonneg._simp_1",
"Int",
"LE.le",
"Nat.cast",
"instOfNat",
"of_eq_true",
"instNatCastInt",
"OfNat.ofNat",
"Int.instLEInt"
]
}
] | simp [← coe_lcm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GCDMonoid.Multiset | {
"line": 182,
"column": 53
} | {
"line": 182,
"column": 61
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizedGCDMonoid α\ninst✝ : DecidableEq α\ns✝ : Multiset α\na : α\ns : Multiset α\nIH : s.dedup.gcd = s.gcd\nh : a ∈ s\n⊢ GCDMonoid.gcd a (fold GCDMonoid.gcd 0 (s.erase a)) =\n GCDMonoid.gcd (GCDMonoid.gcd a a) (fold GCDMonoid.gcd 0 ... | gcd_same | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Permutation | {
"line": 177,
"column": 72
} | {
"line": 177,
"column": 95
} | [
{
"pp": "case cons\nα : Type u_1\nt : α\nts : List α\nr : List (List α)\nl : List α\nL : List (List α)\nih :\n foldr (fun y r ↦ (permutationsAux2 t ts r y id).snd) r L =\n flatMap (fun y ↦ (permutationsAux2 t ts [] y id).snd) L ++ r\n⊢ (permutationsAux2 t ts (flatMap (fun y ↦ (permutationsAux2 t ts [] y id)... | permutationsAux2_append | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.List.Permutation | {
"line": 369,
"column": 44
} | {
"line": 369,
"column": 67
} | [
{
"pp": "case succ.refine_2.e_b.h\nα : Type u_1\nn : ℕ\nIH : ∀ (ts : List α), ts.length < n → ts.permutations ~ ts.permutations'\nts✝ : List α\nh✝ : ts✝.length < n + 1\nts : List α\nt : α\nx✝¹ : ts.length < n + 1 → ts.permutations ~ ts.permutations'\nh : ts.length < n\nIH₂ : ts.reverse.permutations ~ ts.permuta... | permutationsAux2_append | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.GroupAction.Basic | {
"line": 148,
"column": 4
} | {
"line": 148,
"column": 19
} | [
{
"pp": "case h.a\nG : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝² : Group G\ninst✝¹ : MulAction G α\ninst✝ : MulAction G β\na : α\ng h : G\n⊢ ↑((h * g⁻¹) • ⟨(fun m ↦ m • a) g, ⋯⟩) = ↑⟨(fun m ↦ m • a) h, ⋯⟩",
"usedConstants": [
"instHSMul",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
... | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.GroupTheory.GroupAction.Basic | {
"line": 209,
"column": 4
} | {
"line": 209,
"column": 19
} | [
{
"pp": "case h.a\nG : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝² : Group G\ninst✝¹ : MulAction G α\ninst✝ : MulAction G β\na✝ : α\ng : G\nyh : (fun m ↦ m • a✝) g ∈ orbitRel.Quotient.orbit (Quotient.mk'' a✝)\nh : G\nzh : (fun m ↦ m • a✝) h ∈ orbitRel.Quotient.orbit (Quotient.mk'' a✝)\n⊢ ↑((h * g⁻¹) • ⟨(fun m ... | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.GroupTheory.GroupAction.Quotient | {
"line": 288,
"column": 34
} | {
"line": 288,
"column": 49
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\ninst✝³ : Group α\ninst✝² : MulAction α β\nx : β\ninst✝¹ : IsPretransitive α β\nH : Subgroup α\ninst✝ : Finite (α ⧸ H)\nb : β\nh' : Finite (Quotient (rightRel H))\na : Quotient (rightRel H)\ng₁ g₂ : α\nr : g₁ * g₂⁻¹ ∈ H\n⊢ ⟨g₁ * g₂⁻¹, r⟩ • g₂ • b = g₁ • b",
"usedC... | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.GroupTheory.GroupAction.Quotient | {
"line": 288,
"column": 34
} | {
"line": 288,
"column": 49
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\ninst✝³ : Group α\ninst✝² : MulAction α β\nx : β\ninst✝¹ : IsPretransitive α β\nH : Subgroup α\ninst✝ : Finite (α ⧸ H)\nb : β\nh' : Finite (Quotient (rightRel H))\na : Quotient (rightRel H)\ng₁ g₂ : α\nr : g₁ * g₂⁻¹ ∈ H\n⊢ ⟨g₁ * g₂⁻¹, r⟩ • g₂ • b = g₁ • b",
"usedC... | simp [mul_smul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.GroupAction.Quotient | {
"line": 288,
"column": 34
} | {
"line": 288,
"column": 49
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\ninst✝³ : Group α\ninst✝² : MulAction α β\nx : β\ninst✝¹ : IsPretransitive α β\nH : Subgroup α\ninst✝ : Finite (α ⧸ H)\nb : β\nh' : Finite (Quotient (rightRel H))\na : Quotient (rightRel H)\ng₁ g₂ : α\nr : g₁ * g₂⁻¹ ∈ H\n⊢ ⟨g₁ * g₂⁻¹, r⟩ • g₂ • b = g₁ • b",
"usedC... | simp [mul_smul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.GroupAction.Quotient | {
"line": 367,
"column": 22
} | {
"line": 367,
"column": 37
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\ninst✝³ : Group α\ninst✝² : MulAction α β\nx : β\ninst✝¹ : IsPretransitive α β\ninst✝ : IsCancelSMul α β\nH : Subgroup α\nq : α ⧸ H\ng₁ g₂ : α\nh : g₁⁻¹ * g₂ ∈ H\n⊢ (fun m ↦ m • g₂⁻¹ • x) ⟨g₁⁻¹ * g₂, h⟩ = g₁⁻¹ • x",
"usedConstants": [
"Semigroup.toMul",
... | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.GroupTheory.GroupAction.Quotient | {
"line": 367,
"column": 22
} | {
"line": 367,
"column": 37
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\ninst✝³ : Group α\ninst✝² : MulAction α β\nx : β\ninst✝¹ : IsPretransitive α β\ninst✝ : IsCancelSMul α β\nH : Subgroup α\nq : α ⧸ H\ng₁ g₂ : α\nh : g₁⁻¹ * g₂ ∈ H\n⊢ (fun m ↦ m • g₂⁻¹ • x) ⟨g₁⁻¹ * g₂, h⟩ = g₁⁻¹ • x",
"usedConstants": [
"Semigroup.toMul",
... | simp [mul_smul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.GroupAction.Quotient | {
"line": 367,
"column": 22
} | {
"line": 367,
"column": 37
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\ninst✝³ : Group α\ninst✝² : MulAction α β\nx : β\ninst✝¹ : IsPretransitive α β\ninst✝ : IsCancelSMul α β\nH : Subgroup α\nq : α ⧸ H\ng₁ g₂ : α\nh : g₁⁻¹ * g₂ ∈ H\n⊢ (fun m ↦ m • g₂⁻¹ • x) ⟨g₁⁻¹ * g₂, h⟩ = g₁⁻¹ • x",
"usedConstants": [
"Semigroup.toMul",
... | simp [mul_smul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Log | {
"line": 211,
"column": 2
} | {
"line": 212,
"column": 30
} | [
{
"pp": "case inl\nb m n : ℕ\nh : m ≠ 0 ∨ 1 < b ∧ n ≠ 0\nhb : 1 < b\nhn : n ≠ 0\n⊢ log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)",
"usedConstants": [
"instPowNat",
"Eq.mpr",
"congrArg",
"Nat.log_lt_iff_lt_pow",
"Iff.rfl",
"PartialOrder.toPreorder",
"Preorder.toLE",
... | · rw [le_antisymm_iff, ← Nat.lt_succ_iff, le_log_iff_pow_le, log_lt_iff_lt_pow,
and_comm] <;> assumption | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Nat.Log | {
"line": 216,
"column": 4
} | {
"line": 216,
"column": 57
} | [
{
"pp": "case inr.inl\nb m n : ℕ\nh : m ≠ 0 ∨ 1 < b ∧ n ≠ 0\nhm : m ≠ 0\nhb : b ≤ 1\n⊢ log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)",
"usedConstants": [
"Nat.le_one_iff_eq_zero_or_eq_one",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat",
"Iff.mp",
"Or",
"OfNat.ofNat"... | obtain rfl | rfl := le_one_iff_eq_zero_or_eq_one.1 hb | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Nat.Log | {
"line": 451,
"column": 37
} | {
"line": 451,
"column": 59
} | [
{
"pp": "b x : ℕ\nhb : 1 < b\nz : ℕ\n⊢ clog b (b ^ x) ≤ z ↔ x ≤ z",
"usedConstants": [
"instPowNat",
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Nat.clog_le_iff_le_pow",
"id",
"LE.le",
"instLENat",
"instNatPowNat",
"Iff... | clog_le_iff_le_pow hb, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Factors | {
"line": 174,
"column": 8
} | {
"line": 174,
"column": 24
} | [
{
"pp": "case refine_1\nl : List ℕ\nh₂ : ∀ (p : ℕ), p ∈ l → Prime p\nh₁ : l.prod = 0\n⊢ False",
"usedConstants": [
"MulOne.toOne",
"IsDomain.to_noZeroDivisors",
"MulZeroClass.toMul",
"Nat.instNontrivial",
"congrArg",
"Membership.mem",
"Eq.mp",
"Nat.instIsDomai... | prod_eq_zero_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Cycle | {
"line": 843,
"column": 8
} | {
"line": 843,
"column": 33
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\nl m : List α\na : α\n_H : ∀ (hl : m ≠ []), Chain r ↑m ↔ IsChain r (m.getLast hl :: m)\nhl✝ : m ++ [a] ≠ []\n⊢ Chain r ↑(m ++ [a]) ↔ IsChain r ((m ++ [a]).getLast hl✝ :: (m ++ [a]))",
"usedConstants": [
"List.getLast",
"Eq.mpr",
"congrArg",
"Cy... | ← coe_cons_eq_coe_append, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Cycle | {
"line": 854,
"column": 18
} | {
"line": 854,
"column": 43
} | [
{
"pp": "r : ℕ → ℕ → Prop\nn : ℕ\n⊢ Chain r ↑(range n ++ [n]) ↔ r n 0 ∧ ∀ m < n, r m m.succ",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Cycle.coe_cons_eq_coe_append",
"id",
"instOfNatNat",
"List.range",
"Cycle.Chain",
"List.cons",
"Cycle.ofList",
"... | ← coe_cons_eq_coe_append, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Index | {
"line": 310,
"column": 59
} | {
"line": 311,
"column": 73
} | [
{
"pp": "G : Type u_1\nG' : Type u_2\ninst✝¹ : Group G\ninst✝ : Group G'\nH : Subgroup G\nf : G →* G'\n⊢ (map f H).index = (H ⊔ f.ker).index * f.range.index",
"usedConstants": [
"Eq.mpr",
"MonoidHom.range",
"Lattice.toSemilatticeSup",
"Subgroup.map_le_range",
"Subgroup.relIndex... | by
rw [← comap_map_eq, index_comap, relIndex_mul_index (H.map_le_range f)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Index | {
"line": 421,
"column": 2
} | {
"line": 421,
"column": 36
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nJ K : Subgroup G\nhJK : J.relIndex K ≠ 0\nL : Subgroup G\n⊢ (comap L.subtype J).relIndex (comap L.subtype K) ≠ 0",
"usedConstants": [
"Subgroup.subtype",
"Membership.mem",
"Subtype",
"Subgroup",
"Subgroup.relIndex_comap_ne_zero",
"S... | exact relIndex_comap_ne_zero _ hJK | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.GroupTheory.Index | {
"line": 492,
"column": 4
} | {
"line": 492,
"column": 24
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\na : G\nha : ∀ (b : G), b * a ∈ H ∨ b ∈ H\n⊢ H.index ∣ 2",
"usedConstants": [
"Dvd.dvd",
"Classical.propDecidable",
"Membership.mem",
"Subgroup",
"instOfNatNat",
"dite",
"Nat.instDvd",
"Nat",
"Subgro... | by_cases ha' : a ∈ H | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Algebra.Order.Ring.GeomSum | {
"line": 67,
"column": 4
} | {
"line": 67,
"column": 21
} | [
{
"pp": "case refine_1\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : PartialOrder R\ninst✝ : IsStrictOrderedRing R\nn : ℕ\nx : R\nhx : x < 0\nhx' : 0 < x + 1\nhn : 1 < n\n⊢ 0 < ∑ i ∈ range 2, x ^ i ∧ ∑ i ∈ range 2, x ^ i < 1",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
... | rw [geom_sum_two] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.ZMod.Basic | {
"line": 156,
"column": 2
} | {
"line": 156,
"column": 30
} | [
{
"pp": "p n q : ℕ\nh : n ≤ n + q\n⊢ ↑p ^ (n + q) = 0",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"ZMod.commRing",
"Monoid.toMulOneClass",
... | rw [pow_add, ← Nat.cast_pow] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.ZMod.Basic | {
"line": 552,
"column": 36
} | {
"line": 552,
"column": 50
} | [
{
"pp": "case succ\nR : Type u_1\ninst✝ : Ring R\nn : ℕ\n⊢ ↑n = ↑(n + 1) - 1",
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"AddMonoid.toAddSemigroup",
"AddGroupWithOne.toAddGroup",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
"HSub.hSub",
"id",
"A... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.ZMod.Basic | {
"line": 669,
"column": 4
} | {
"line": 669,
"column": 45
} | [
{
"pp": "case succ\nn✝ : ℕ\na b : ZMod (n✝ + 1)\n⊢ (a + b).val ≤ a.val + b.val",
"usedConstants": [
"Eq.mpr",
"instNeZeroNatHAdd_1",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"ZMod.commRing",
"congrArg",
"ZMod.val_add",
"... | simpa [ZMod.val_add] using Nat.mod_le _ _ | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Data.ZMod.Basic | {
"line": 669,
"column": 4
} | {
"line": 669,
"column": 45
} | [
{
"pp": "case succ\nn✝ : ℕ\na b : ZMod (n✝ + 1)\n⊢ (a + b).val ≤ a.val + b.val",
"usedConstants": [
"Eq.mpr",
"instNeZeroNatHAdd_1",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"ZMod.commRing",
"congrArg",
"ZMod.val_add",
"... | simpa [ZMod.val_add] using Nat.mod_le _ _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ZMod.Basic | {
"line": 669,
"column": 4
} | {
"line": 669,
"column": 45
} | [
{
"pp": "case succ\nn✝ : ℕ\na b : ZMod (n✝ + 1)\n⊢ (a + b).val ≤ a.val + b.val",
"usedConstants": [
"Eq.mpr",
"instNeZeroNatHAdd_1",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"ZMod.commRing",
"congrArg",
"ZMod.val_add",
"... | simpa [ZMod.val_add] using Nat.mod_le _ _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.ZMod.Basic | {
"line": 949,
"column": 25
} | {
"line": 949,
"column": 63
} | [
{
"pp": "case inl\na : ℤ\nh✝ : a ≤ 0\n⊢ ↑|a| = ↑a",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast_neg",
"Int.cast",
"NegZeroClass.toNeg",
"ZMod.commRing",
"AddGroupWithOne.toAddGroup",
"abs",
"congrArg",
"SubtractionMonoid.toSubNegZeroMono... | simp [abs_of_nonneg, abs_of_nonpos, *] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.ZMod.Basic | {
"line": 949,
"column": 25
} | {
"line": 949,
"column": 63
} | [
{
"pp": "case inr\na : ℤ\nh✝ : 0 ≤ a\n⊢ ↑|a| = ↑a",
"usedConstants": [
"Int.cast",
"ZMod.commRing",
"abs",
"congrArg",
"instOfNatNat",
"Int",
"AddGroupWithOne.toIntCast",
"ZMod",
"Nat",
"True",
"eq_self",
"instLatticeInt",
"abs_of... | simp [abs_of_nonneg, abs_of_nonpos, *] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.ZMod.Basic | {
"line": 976,
"column": 10
} | {
"line": 976,
"column": 19
} | [
{
"pp": "case succ.mp.zero\nn✝ : ℕ\na : ZMod (n✝ + 1)\nhe : 2 * a.val = (n✝ + 1) * 0\n⊢ a = 0 ∨ 2 * a.val = n✝ + 1",
"usedConstants": [
"Nat.instMulZeroClass",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"Eq.mp",
"instMulNat",
"instOfNatNat",
"MulZeroClass.... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.Divisors | {
"line": 415,
"column": 20
} | {
"line": 415,
"column": 33
} | [
{
"pp": "case h\np : ℕ\npp : Prime p\na✝ : ℕ\n⊢ a✝ ∣ p ∧ p ≠ 0 ↔ a✝ ∈ {1, p}",
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"congrArg",
"Finset",
"Membership.mem",
"id",
"Insert.insert",
"Ne",
"instOfNatNat",
"Nat.dvd_prime",
"Finset.instInsert",
... | dvd_prime pp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.ZMod.Basic | {
"line": 1072,
"column": 8
} | {
"line": 1072,
"column": 17
} | [
{
"pp": "case inl\nn : ℕ\nx : ℤ\nhl : x.natAbs ≤ n / 2\n⊢ x.natAbs ≤ (↑n * 0 + x).natAbs",
"usedConstants": [
"Eq.mpr",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"MulZeroClass.toMul",
"congrArg",
"AddMonoid.toAddZe... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Digits.Defs | {
"line": 169,
"column": 77
} | {
"line": 174,
"column": 8
} | [
{
"pp": "b : ℕ\nl1 l2 : List ℕ\n⊢ ofDigits b (l1 ++ l2) = ofDigits b l1 + b ^ l1.length * ofDigits b l2",
"usedConstants": [
"Nat.pow_succ'",
"instPowNat",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.Ring.single_pow",
"MulOne.toOne",
"HMul.h... | by
induction l1 with
| nil => simp [ofDigits]
| cons hd tl IH =>
rw [ofDigits, List.cons_append, ofDigits, IH, List.length_cons, pow_succ']
ring | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Digits.Defs | {
"line": 179,
"column": 43
} | {
"line": 179,
"column": 52
} | [
{
"pp": "b : ℕ\nl : List ℕ\n⊢ ofDigits b l + b ^ l.length * 0 = ofDigits b l",
"usedConstants": [
"Eq.mpr",
"Nat.instMulZeroClass",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"Nat.instMonoid",
"Nat.ofDigits",
"id",
"instMulNat",
"instOfNatNat",... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Digits.Defs | {
"line": 385,
"column": 90
} | {
"line": 387,
"column": 32
} | [
{
"pp": "b m : ℕ\n⊢ m < (b + 2) ^ ((b + 2).digits m).length",
"usedConstants": [
"Eq.mpr",
"Nat.ofDigits_lt_base_pow_length'",
"congrArg",
"HEq.refl",
"Nat.instMonoid",
"Nat.ofDigits",
"Eq.casesOn",
"id",
"instOfNatNat",
"Monoid.toPow",
"Nat.... | by
convert @ofDigits_lt_base_pow_length' b (digits (b + 2) m) fun _ => digits_lt_base'
rw [ofDigits_digits (b + 2) m] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Digits.Defs | {
"line": 390,
"column": 90
} | {
"line": 391,
"column": 69
} | [
{
"pp": "b m : ℕ\nhb : 1 < b\n⊢ m < b ^ (b.digits m).length",
"usedConstants": [
"not_lt_zero._simp_1",
"Nat.instCanonicallyOrderedAdd",
"False",
"congrArg",
"Nat.instMonoid",
"False.elim",
"AddMonoid.toAddZeroClass",
"Nat.instAddMonoid",
"lt_self_iff_fa... | by
rcases b with (_ | _ | b) <;> simp_all [lt_base_pow_length_digits'] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 167,
"column": 2
} | {
"line": 179,
"column": 47
} | [
{
"pp": "p n k l : ℕ\nhn : n ≠ 0\nh : p ^ k * l = n\nhl : ¬p ∣ l\n⊢ p.maxPowDvdDiv n = (k, l)",
"usedConstants": [
"_private.Mathlib.Data.Nat.MaxPowDiv.0.Nat.pow_dvd_iff_le_of_spec",
"instPowNat",
"Eq.mpr",
"False",
"Nat.mul_left_cancel_iff",
"Dvd.dvd",
"HMul.hMul",... | obtain rfl | rfl | hp : p = 0 ∨ p = 1 ∨ 1 < p := by grind
· cases k.eq_zero_or_pos <;> simp_all
· simp_all
· have hk : k = (p.maxPowDvdDiv n).1 := by
· apply Nat.le_antisymm
· rw [← padicValNat, ← pow_dvd_iff_le_padicValNat (Nat.ne_of_gt hp) hn,
pow_dvd_iff_le_of_spec hp hn h hl]
... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 167,
"column": 2
} | {
"line": 179,
"column": 47
} | [
{
"pp": "p n k l : ℕ\nhn : n ≠ 0\nh : p ^ k * l = n\nhl : ¬p ∣ l\n⊢ p.maxPowDvdDiv n = (k, l)",
"usedConstants": [
"_private.Mathlib.Data.Nat.MaxPowDiv.0.Nat.pow_dvd_iff_le_of_spec",
"instPowNat",
"Eq.mpr",
"False",
"Nat.mul_left_cancel_iff",
"Dvd.dvd",
"HMul.hMul",... | obtain rfl | rfl | hp : p = 0 ∨ p = 1 ∨ 1 < p := by grind
· cases k.eq_zero_or_pos <;> simp_all
· simp_all
· have hk : k = (p.maxPowDvdDiv n).1 := by
· apply Nat.le_antisymm
· rw [← padicValNat, ← pow_dvd_iff_le_padicValNat (Nat.ne_of_gt hp) hn,
pow_dvd_iff_le_of_spec hp hn h hl]
... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 189,
"column": 31
} | {
"line": 189,
"column": 39
} | [
{
"pp": "case inl.cons.inr\np : ℕ\nh : 1 < p\nhd : ℕ\ntl : List ℕ\nih✝ :\n ∀ {h_nonempty : tl ≠ []},\n tl.getLast h_nonempty ≠ 0 →\n (∀ l ∈ tl, l < p) → (p - 1) * ∑ i ∈ range tl.length, ofDigits p tl / p ^ i.succ = ofDigits p tl - tl.sum\nh_nonempty : hd :: tl ≠ []\nh_ne_zero : (hd :: tl).getLast h_non... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 189,
"column": 40
} | {
"line": 189,
"column": 48
} | [
{
"pp": "case inl.cons.inr\np : ℕ\nh : 1 < p\nhd : ℕ\ntl : List ℕ\nih✝ :\n ∀ {h_nonempty : tl ≠ []},\n tl.getLast h_nonempty ≠ 0 →\n (∀ l ∈ tl, l < p) → (p - 1) * ∑ i ∈ range tl.length, ofDigits p tl / p ^ i.succ = ofDigits p tl - tl.sum\nh_nonempty : hd :: tl ≠ []\nh_ne_zero : (hd :: tl).getLast h_non... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 190,
"column": 12
} | {
"line": 190,
"column": 21
} | [
{
"pp": "case inl.cons.inr\np : ℕ\nh : 1 < p\nhd : ℕ\ntl : List ℕ\nih✝ :\n ∀ {h_nonempty : tl ≠ []},\n tl.getLast h_nonempty ≠ 0 →\n (∀ l ∈ tl, l < p) → (p - 1) * ∑ i ∈ range tl.length, ofDigits p tl / p ^ i.succ = ofDigits p tl - tl.sum\nh_nonempty : hd :: tl ≠ []\nh_ne_zero : (hd :: tl).getLast h_non... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 108,
"column": 5
} | {
"line": 108,
"column": 75
} | [
{
"pp": "a b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\nh : ∀ (p : ℕ), a.factorization p = b.factorization p\n⊢ a.primeFactorsList ~ b.primeFactorsList",
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instMulZeroClass",
"congrArg",
"_private.Mathlib.Data.Nat.Factorization.Defs.0.Na... | by simpa only [List.perm_iff_count, primeFactorsList_count_eq] using h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 285,
"column": 6
} | {
"line": 285,
"column": 24
} | [
{
"pp": "case h\na b : ℕ\nhab : a.Coprime b\nq : ℕ\n⊢ (a * b).factorization q = (a.factorization + b.factorization) q",
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instMulZeroClass",
"HMul.hMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"Finsupp.add_appl... | Finsupp.add_apply, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 309,
"column": 2
} | {
"line": 311,
"column": 63
} | [
{
"pp": "a b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\n⊢ (∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p) ↔ a ∣ b",
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Finsupp.instLE",
"... | rw [← factorization_le_iff_dvd ha hb, Finsupp.le_def]
congr! 1 with p
obtain _ | _ | p := p <;> simp [Nat.pow_dvd_pow_iff_le_right] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 309,
"column": 2
} | {
"line": 311,
"column": 63
} | [
{
"pp": "a b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\n⊢ (∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p) ↔ a ∣ b",
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Finsupp.instLE",
"... | rw [← factorization_le_iff_dvd ha hb, Finsupp.le_def]
congr! 1 with p
obtain _ | _ | p := p <;> simp [Nat.pow_dvd_pow_iff_le_right] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Multiplicity | {
"line": 216,
"column": 4
} | {
"line": 218,
"column": 44
} | [
{
"pp": "case isTrue\nα : Type u_1\ninst✝ : Monoid α\na b : α\nm : ℕ\nnh : a ^ m ∣ b\nh✝ : FiniteMultiplicity a b\nhm : ↑(Nat.find h✝) < ↑m\n⊢ False",
"usedConstants": [
"instDecidableNot",
"False",
"Preorder.toLT",
"Dvd.dvd",
"instCharZeroENat",
"instAddMonoidWithOneENat... | simp only [cast_lt, find_lt_iff] at hm
obtain ⟨n, hn1, hn2⟩ := hm
exact hn2 ((pow_dvd_pow _ hn1).trans nh) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Multiplicity | {
"line": 216,
"column": 4
} | {
"line": 218,
"column": 44
} | [
{
"pp": "case isTrue\nα : Type u_1\ninst✝ : Monoid α\na b : α\nm : ℕ\nnh : a ^ m ∣ b\nh✝ : FiniteMultiplicity a b\nhm : ↑(Nat.find h✝) < ↑m\n⊢ False",
"usedConstants": [
"instDecidableNot",
"False",
"Preorder.toLT",
"Dvd.dvd",
"instCharZeroENat",
"instAddMonoidWithOneENat... | simp only [cast_lt, find_lt_iff] at hm
obtain ⟨n, hn1, hn2⟩ := hm
exact hn2 ((pow_dvd_pow _ hn1).trans nh) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Multiplicity | {
"line": 583,
"column": 2
} | {
"line": 583,
"column": 54
} | [
{
"pp": "α : Type u_1\ninst✝ : Ring α\np a b : α\nh : multiplicity p b < multiplicity p a\nhfin : FiniteMultiplicity p b\n⊢ multiplicity p (a - b) = multiplicity p b",
"usedConstants": [
"Eq.mpr",
"NegZeroClass.toNeg",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
"congr... | rw [sub_eq_add_neg, hfin.neg.multiplicity_add_of_gt] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Choose.Factorization | {
"line": 190,
"column": 4
} | {
"line": 190,
"column": 39
} | [
{
"pp": "p n k : ℕ\nh : ¬(n.choose k).factorization p = 0\nhp : Prime p\n⊢ k ≤ n",
"usedConstants": [
"Preorder.toLT",
"PartialOrder.toPreorder",
"le_of_not_gt",
"Nat",
"LT.lt",
"LinearOrder.toPartialOrder",
"Nat.instLinearOrder"
]
}
] | refine le_of_not_gt fun hnk => h ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Nat.Multiplicity | {
"line": 179,
"column": 50
} | {
"line": 181,
"column": 33
} | [
{
"pp": "p n r b : ℕ\nhp : Prime p\nhbn : log p n < b\n⊢ p ^ r ∣ n ! ↔ r ≤ ∑ i ∈ Ico 1 b, n / p ^ i",
"usedConstants": [
"Eq.mpr",
"ENat.some_eq_coe",
"Dvd.dvd",
"instHDiv",
"ENat.instNatCast",
"Nat.Prime.emultiplicity_factorial",
"congrArg",
"Nat.instMonoid",... | by
rw [← WithTop.coe_le_coe, ENat.some_eq_coe, ← hp.emultiplicity_factorial hbn,
pow_dvd_iff_le_emultiplicity] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.OrderOfElement | {
"line": 271,
"column": 19
} | {
"line": 271,
"column": 37
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx : G\nn : ℕ\nh : orderOf x ∣ n\n⊢ x ^ n = 1",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Monoid.toMulOneClass",
"congrArg",
"pow_mod_orderOf",
"id",
"Nat.instMod",
"instHMod",
"Monoid.toPow",
"orderOf",
... | ← pow_mod_orderOf, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Inductions | {
"line": 169,
"column": 33
} | {
"line": 169,
"column": 44
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\nP : R[X] → Prop\np : R[X]\nh0 : 0 < p.degree\nhC : ∀ {a : R}, a ≠ 0 → P (C a * X)\nhX : ∀ {p : R[X]}, 0 < p.degree → P p → P (p * X)\nhadd : ∀ {p : R[X]} {a : R}, 0 < p.degree → P p → P (p + C a)\nh : 0 < degree 0\n⊢ P 0",
"usedConstants": [
"WithBot.instPreord... | degree_zero | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.OrderOfElement | {
"line": 321,
"column": 30
} | {
"line": 321,
"column": 48
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx : G\nn : ℕ\nh✝ : n.Coprime (orderOf x)\nh0 : ¬orderOf x = 0\nh1 : ¬orderOf x = 1\nm : ℕ\nh : n * m % orderOf x = 1\n⊢ x ^ (n * m) = x",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"pow_mod_orderOf",
"id",
"Nat.instMod",... | ← pow_mod_orderOf, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.OrderOfElement | {
"line": 569,
"column": 67
} | {
"line": 569,
"column": 85
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx : G\nhx : IsOfFinOrder x\nn : ℕ\n⊢ x ^ n = x ^ ↑⟨n % orderOf x, ⋯⟩",
"usedConstants": [
"Eq.mpr",
"IsOfFinOrder.orderOf_pos",
"congrArg",
"pow_mod_orderOf",
"Fin.mk",
"id",
"Nat.instMod",
"instHMod",
"Fin.val",
... | ← pow_mod_orderOf, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Tactic.ComputeDegree | {
"line": 129,
"column": 4
} | {
"line": 129,
"column": 39
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝ : Semiring R\nm n : ℕ\np : R[X]\nh_pow : p.natDegree ≤ n\nh_exp : m * n ≤ m * n\n⊢ (p ^ m).coeff (m * n) = p.coeff n ^ m",
"usedConstants": [
"Polynomial.coeff_pow_of_natDegree_le"
]
}
] | exact coeff_pow_of_natDegree_le ‹_› | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.GroupTheory.OrderOfElement | {
"line": 1053,
"column": 2
} | {
"line": 1053,
"column": 36
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nx : G\nhx : ¬IsOfFinOrder x\nk : ℤ\nh : zpowers x = zpowers (x ^ k)\nhx_mem : x ∈ zpowers (x ^ k)\nhy_mem : x ^ k ∈ zpowers x\nl : ℤ\nhl : x ^ (k * l) = x\n⊢ x = x ^ k ∨ x⁻¹ = x ^ k",
"usedConstants": [
"HMul.hMul",
"congrArg",
"DivInvMonoid.toZPow",... | nth_rewrite 2 [← zpow_one x] at hl | Mathlib.Tactic._aux_Mathlib_Tactic_NthRewrite___macroRules_Mathlib_Tactic_tacticNth_rewrite______1 | Mathlib.Tactic.tacticNth_rewrite_____ |
Mathlib.GroupTheory.OrderOfElement | {
"line": 1185,
"column": 15
} | {
"line": 1185,
"column": 33
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Group G\ninst✝ : Fintype G\na : G\nn : ℕ\n⊢ a ^ n = a ^ (n % card G)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"pow_mod_orderOf",
"Fintype.card",
"id",
"Nat.instMod",
"instHMod",
"DivInvMonoid.toMonoid",
"Monoid.toPow",
... | ← pow_mod_orderOf, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.OrderOfElement | {
"line": 1194,
"column": 15
} | {
"line": 1194,
"column": 33
} | [
{
"pp": "G : Type u_6\ninst✝ : Group G\na : G\nn : ℕ\n⊢ a ^ n = a ^ (n % Nat.card G)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"pow_mod_orderOf",
"id",
"Nat.instMod",
"Nat.card",
"instHMod",
"DivInvMonoid.toMonoid",
"Monoid.toPow",
"Group.toDivInv... | ← pow_mod_orderOf, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.RingDivision | {
"line": 96,
"column": 12
} | {
"line": 96,
"column": 21
} | [
{
"pp": "case pos\nR : Type u\ninst✝¹ : Semiring R\ninst✝ : NoZeroDivisors R\np q : R[X]\nhp : ¬p = 0\nhq : q = 0\n⊢ (p * 0).trailingDegree = p.trailingDegree + trailingDegree 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"NonUnitalNonAssocSemi... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Expand | {
"line": 67,
"column": 24
} | {
"line": 67,
"column": 54
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\np q : ℕ\nf✝ f g : R[X]\nihf : (expand R p) ((expand R q) f) = (expand R (p * q)) f\nihg : (expand R p) ((expand R q) g) = (expand R (p * q)) g\n⊢ (expand R p) ((expand R q) (f + g)) = (expand R (p * q)) (f + g)",
"usedConstants": [
"Eq.mpr",
"Semiring... | by simp_rw [map_add, ihf, ihg] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Expand | {
"line": 100,
"column": 10
} | {
"line": 100,
"column": 16
} | [
{
"pp": "case pos.h₀.hnc\nR : Type u\ninst✝ : CommSemiring R\np : ℕ\nhp : 0 < p\nf : R[X]\nn : ℕ\nh : p ∣ n\nb : ℕ\na✝ : b ∈ f.support\nhb2 : b ≠ n / p\nhb3 : p * b = n\n⊢ b = n / p",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"congrArg",
"id",
"HDiv.hDiv",
... | ← hb3, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Expand | {
"line": 103,
"column": 6
} | {
"line": 103,
"column": 23
} | [
{
"pp": "case pos.h₁\nR : Type u\ninst✝ : CommSemiring R\np : ℕ\nhp : 0 < p\nf : R[X]\nn : ℕ\nh : p ∣ n\nhn : n / p ∉ f.support\n⊢ (if p * (n / p) = n then 0 else 0) = 0",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"AddMon... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.Polynomial.Expand | {
"line": 136,
"column": 34
} | {
"line": 136,
"column": 43
} | [
{
"pp": "case inl\nR : Type u\ninst✝ : CommSemiring R\np : ℕ\nf : R[X]\nhp : p = 0\n⊢ (eval₂ C 1 f).natDegree = f.natDegree * 0",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"MulOne.toOne",
"Nat.instMulZeroClass",
"HMul.hMul",
"MulZeroClass.toMul",
"Monoid.toMulOne... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 67,
"column": 25
} | {
"line": 67,
"column": 34
} | [
{
"pp": "case h₀.zero\nR : Type u\ninst✝ : Semiring R\np : R[X]\nn : ℕ\na✝¹ : 0 ∈ p.support\na✝ : 0 ≠ n + 1\n⊢ (p.coeff 0 * 0 * if n = 0 - 1 then 1 else 0) = 0",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Expand | {
"line": 221,
"column": 36
} | {
"line": 221,
"column": 52
} | [
{
"pp": "case a.h\nR : Type u\ninst✝ : CommSemiring R\np : ℕ\nhp : p ≠ 0\nf g : R[X]\nn : ℕ\n⊢ ∀ ⦃x : ℕ × ℕ⦄, (∃ a ∈ antidiagonal n, (a.1 * p, a.2 * p) = x) → x ∈ antidiagonal (n * p)",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"_private.Mathlib.Algebra.Po... | mem_antidiagonal | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Polynomial.Expand | {
"line": 222,
"column": 22
} | {
"line": 222,
"column": 38
} | [
{
"pp": "case a.hf\nR : Type u\ninst✝ : CommSemiring R\np : ℕ\nhp : p ≠ 0\nf g : R[X]\nn : ℕ\n⊢ ∀ x ∈ antidiagonal (n * p),\n (¬∃ a ∈ antidiagonal n, (a.1 * p, a.2 * p) = x) → f.coeff x.1 * ((expand R p) g).coeff x.2 = 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"AddMonoid.toAddSemigr... | mem_antidiagonal | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Polynomial.Expand | {
"line": 259,
"column": 20
} | {
"line": 259,
"column": 32
} | [
{
"pp": "case zero\nR : Type u\ninst✝³ : CommSemiring R\ninst✝² : NoZeroDivisors R\nf : R[X]\nhf : derivative f = 0\ninst✝¹ : CharZero R\ninst✝ : ExpChar R 1\n⊢ contract 1 f = f",
"usedConstants": [
"Eq.mpr",
"congrArg",
"CommSemiring.toSemiring",
"id",
"instOfNatNat",
"P... | contract_one | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Expand | {
"line": 260,
"column": 2
} | {
"line": 260,
"column": 69
} | [
{
"pp": "case prime\nR : Type u\ninst✝² : CommSemiring R\np : ℕ\ninst✝¹ : ExpChar R p\ninst✝ : NoZeroDivisors R\nf : R[X]\nhf : derivative f = 0\nhprime : Nat.Prime p\nhchar : CharP R p\n⊢ (expand R p) (contract p f) = f",
"usedConstants": [
"Polynomial.expand_contract",
"Nat.Prime.ne_zero"
... | · haveI := Fact.mk hchar; exact expand_contract p hf hprime.ne_zero | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Polynomial.Div | {
"line": 181,
"column": 51
} | {
"line": 182,
"column": 38
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\np : R[X]\n⊢ 0 %ₘ p = 0",
"usedConstants": [
"_private.Mathlib.Algebra.Polynomial.Div.0.Polynomial.zero_modByMonic._proof_1_4"
]
}
] | by
grind [modByMonic, divModByMonicAux] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Div | {
"line": 225,
"column": 4
} | {
"line": 225,
"column": 49
} | [
{
"pp": "case pos.inr\nR : Type u\ninst✝ : Ring R\np q : R[X]\na✝ : Nontrivial R\nhq : q.Monic\nh✝ : q.degree ≤ p.degree\n⊢ (p %ₘ q).degree ≤ p.degree",
"usedConstants": [
"WithBot.instPreorder",
"WithBot",
"Polynomial.degree_modByMonic_le",
"Polynomial.degree",
"Nat.instPreord... | · exact (degree_modByMonic_le p hq).trans ‹_› | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Polynomial.Div | {
"line": 251,
"column": 59
} | {
"line": 251,
"column": 67
} | [
{
"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_wf : (p - q * (C p.leadingCoeff * X ^ (p.natDegree - q.natDegree))).degree < p.degree\nih :\n ((p - q * (C p.leadingCoeff * X ^ (p.natDegree - q.natDegree))).divModByMonic... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Div | {
"line": 255,
"column": 56
} | {
"line": 255,
"column": 65
} | [
{
"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⊢ (0, p).2 = p - q * (0, p).1",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Ring.toNonAssocRing",
"MulZeroClass.toMul",
"congrArg",
... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Div | {
"line": 257,
"column": 76
} | {
"line": 257,
"column": 85
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\np q : R[X]\nthis : DecidableEq R := Classical.decEq R\nhq : ¬q.Monic\n⊢ p = p - q * 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Ring.toNonAssocRing",
"MulZeroClass.toMul",
"congrArg",
"HSub.hSub",
"NonUnitalNonAssocSemiring.to... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Div | {
"line": 266,
"column": 12
} | {
"line": 266,
"column": 21
} | [
{
"pp": "R : Type u\ninst✝¹ : Ring R\np q : R[X]\ninst✝ : Nontrivial R\nhq : q.Monic\nh : p /ₘ q = 0\nthis : p %ₘ q + q * 0 = p\n⊢ p.degree < q.degree",
"usedConstants": [
"HMul.hMul",
"Ring.toNonAssocRing",
"MulZeroClass.toMul",
"congrArg",
"NonUnitalNonAssocSemiring.toMulZero... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Div | {
"line": 401,
"column": 50
} | {
"line": 401,
"column": 59
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\np q : R[X]\nhq : q.Monic\nh✝ : q ∣ p\na✝ : Nontrivial R\nr : R[X]\nhr : p = q * r\nhpq0 : ¬p %ₘ q = 0\nhmod : p %ₘ q = q * (r - p /ₘ q)\nthis : (q * (r - p /ₘ q)).degree < q.degree\nh : (r - p /ₘ q).leadingCoeff = 0\n⊢ (q * 0).leadingCoeff = 0",
"usedConstants": [
... | mul_zero, | 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.