module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.Algebra.Polynomial.Reverse | {
"line": 236,
"column": 6
} | {
"line": 236,
"column": 20
} | {
"line": 236,
"column": 21
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\nf : R[X]\nn : ℕ\nhn : f.natDegree < n\n⊢ f.reverse.coeff n = 0",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.revAt",
"congrArg",
"id",
"Polynomial.coeff",
"Function.Embedding",
"Nat... | [
"R : Type u_1\ninst✝ : Semiring R\nf : R[X]\nn : ℕ\nhn : f.natDegree < n\n⊢ f.coeff ((revAt f.natDegree) n) = 0"
] | coeff_reverse, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Reverse | {
"line": 251,
"column": 23
} | {
"line": 251,
"column": 37
} | {
"line": 251,
"column": 38
} | [
{
"pp": "case a\nR : Type u_1\ninst✝ : Semiring R\nf : R[X]\nhf : ¬f = 0\nkey : ¬f.reverse.coeff f.reverse.natDegree = 0\n⊢ f.coeff (f.natDegree - f.reverse.natDegree) ≠ 0",
"ppTerm": "?a✝",
"assigned": true,
"usedConstants": [
"Polynomial.revAt",
"congrArg",
"Eq.mp",
"Polyno... | [
"case a\nR : Type u_1\ninst✝ : Semiring R\nf : R[X]\nhf : ¬f = 0\nkey : ¬f.coeff ((revAt f.natDegree) f.reverse.natDegree) = 0\n⊢ f.coeff (f.natDegree - f.reverse.natDegree) ≠ 0"
] | coeff_reverse, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Reverse | {
"line": 254,
"column": 6
} | {
"line": 254,
"column": 61
} | {
"line": 254,
"column": 62
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\nf : R[X]\n⊢ f.reverse.natDegree = f.natDegree - f.natTrailingDegree",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"HSub.hSub",
"id",
"instSubNat",
"instHAdd",
"instHSub",
"HAd... | [
"R : Type u_1\ninst✝ : Semiring R\nf : R[X]\n⊢ f.reverse.natDegree = f.reverse.natDegree + f.natTrailingDegree - f.natTrailingDegree"
] | f.natDegree_eq_reverse_natDegree_add_natTrailingDegree, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Reverse | {
"line": 258,
"column": 4
} | {
"line": 258,
"column": 18
} | {
"line": 258,
"column": 19
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\nf : R[X]\n⊢ f.reverse.coeff ((revAt f.natDegree) f.natTrailingDegree) = f.trailingCoeff",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.revAt",
"congrArg",
"id",
"Polynomial.coeff",
"Functi... | [
"R : Type u_1\ninst✝ : Semiring R\nf : R[X]\n⊢ f.coeff ((revAt f.natDegree) ((revAt f.natDegree) f.natTrailingDegree)) = f.trailingCoeff"
] | coeff_reverse, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Reverse | {
"line": 288,
"column": 6
} | {
"line": 288,
"column": 20
} | {
"line": 288,
"column": 21
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\nf : R[X]\n⊢ f.reverse.coeff 1 = f.nextCoeff",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.revAt",
"congrArg",
"id",
"instOfNatNat",
"Polynomial.coeff",
"Function.Embedding",
"... | [
"R : Type u_1\ninst✝ : Semiring R\nf : R[X]\n⊢ f.coeff ((revAt f.natDegree) 1) = f.nextCoeff"
] | coeff_reverse, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Monic | {
"line": 293,
"column": 4
} | {
"line": 293,
"column": 86
} | {
"line": 294,
"column": 2
} | [
{
"pp": "case pos\nR : Type u\ninst✝ : CommSemiring R\nα : Type u_1\nf : α → R[X]\nhf : ∀ i ∈ Function.mulSupport f, (f i).Monic\nh✝ : Function.HasFiniteMulSupport f\n⊢ (∏ i ∈ Set.Finite.toFinset h✝, f i).Monic",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Po... | [] | exact monic_prod_of_monic _ _ fun a ha => hf a ((Set.Finite.mem_toFinset _).mp ha) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Polynomial.Monic | {
"line": 293,
"column": 4
} | {
"line": 293,
"column": 86
} | {
"line": 294,
"column": 2
} | [
{
"pp": "case pos\nR : Type u\ninst✝ : CommSemiring R\nα : Type u_1\nf : α → R[X]\nhf : ∀ i ∈ Function.mulSupport f, (f i).Monic\nh✝ : Function.HasFiniteMulSupport f\n⊢ (∏ i ∈ Set.Finite.toFinset h✝, f i).Monic",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Po... | [] | exact monic_prod_of_monic _ _ fun a ha => hf a ((Set.Finite.mem_toFinset _).mp ha) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Monic | {
"line": 293,
"column": 4
} | {
"line": 293,
"column": 86
} | {
"line": 294,
"column": 2
} | [
{
"pp": "case pos\nR : Type u\ninst✝ : CommSemiring R\nα : Type u_1\nf : α → R[X]\nhf : ∀ i ∈ Function.mulSupport f, (f i).Monic\nh✝ : Function.HasFiniteMulSupport f\n⊢ (∏ i ∈ Set.Finite.toFinset h✝, f i).Monic",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Po... | [] | exact monic_prod_of_monic _ _ fun a ha => hf a ((Set.Finite.mem_toFinset _).mp ha) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.BigOperators | {
"line": 81,
"column": 4
} | {
"line": 81,
"column": 29
} | {
"line": 83,
"column": 0
} | [
{
"pp": "case some.p1\nι : Type w\nS : Type u_1\ninst✝ : Semiring S\nf : ι → S[X]\ns : Finset ι\nhf : ∑ k ∈ s, (f k).leadingCoeff ≠ 0\nd : ℕ\nhd : ∀ k ∈ s, (f k).natDegree = d\n⊢ (∑ k ∈ s, f k).coeff d ≠ 0",
"ppTerm": "?some.p1",
"assigned": true,
"usedConstants": [
"False",
"eq_false",
... | [] | · simp_all [leadingCoeff] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Polynomial.Monic | {
"line": 344,
"column": 4
} | {
"line": 344,
"column": 55
} | {
"line": 345,
"column": 4
} | [
{
"pp": "case mpr\nR : Type u\ninst✝¹ : CommSemiring R\ninst✝ : NoZeroDivisors R\nf g : R[X]\nhf : f.Monic\nhg : g.Monic\nhp : (f * g).Monic\nh :\n ∀ (f_1 g_1 : R[X]),\n f_1.Monic → g_1.Monic → f_1 * g_1 = f * g → ¬(0 < g_1.natDegree ∧ g_1.natDegree + g_1.natDegree ≤ (f * g).natDegree)\n⊢ f.natDegree = 0 ∨ ... | [
"case mpr\nR : Type u\ninst✝¹ : CommSemiring R\ninst✝ : NoZeroDivisors R\nf g : R[X]\nhf : f.Monic\nhg : g.Monic\nhp : (f * g).Monic\nh :\n ∀ (f_1 g_1 : R[X]),\n f_1.Monic →\n g_1.Monic → f_1 * g_1 = f * g → ¬(g_1.natDegree ≠ 0 ∧ g_1.natDegree + g_1.natDegree ≤ f.natDegree + g.natDegree)\n⊢ f.natDegree = 0... | simp_rw [hf.natDegree_mul hg, pos_iff_ne_zero] at h | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Algebra.MvPolynomial.Equiv | {
"line": 688,
"column": 2
} | {
"line": 707,
"column": 39
} | {
"line": 709,
"column": 0
} | [
{
"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",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Finsupp.instAddZeroClass",
"Finsupp.instFunLike",
... | [] | 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... | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Algebra.MvPolynomial.Equiv | {
"line": 688,
"column": 2
} | {
"line": 707,
"column": 39
} | {
"line": 709,
"column": 0
} | [
{
"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",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Finsupp.instAddZeroClass",
"Finsupp.instFunLike",
... | [] | 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": 688,
"column": 2
} | {
"line": 707,
"column": 39
} | {
"line": 709,
"column": 0
} | [
{
"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",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Finsupp.instAddZeroClass",
"Finsupp.instFunLike",
... | [] | 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.BigOperators | {
"line": 241,
"column": 77
} | {
"line": 242,
"column": 50
} | {
"line": 244,
"column": 0
} | [
{
"pp": "R : Type u\nι : Type w\ns : Finset ι\ninst✝ : CommSemiring R\nf : ι → R[X]\n⊢ (∏ i ∈ s, f i).coeff 0 = ∏ i ∈ s, (f i).coeff 0",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Multiset.map",
"congrArg",
"CommSemiring.toSemiring",
"Multiset.prod",
"Func... | [] | by
simpa using coeff_zero_multiset_prod (s.1.map f) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.BigOperators | {
"line": 335,
"column": 51
} | {
"line": 337,
"column": 76
} | {
"line": 339,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : Nontrivial R\nα : Type u_1\ns : Finset α\nf : α → R\n⊢ (∏ a ∈ s, (X - C (f a))).natDegree = #s",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Multiset.map",
"congrArg",
"CommSemiring... | [] | by
rw [Finset.prod, ← (X - C ·).comp_def f, ← Multiset.map_map,
natDegree_multiset_prod_X_sub_C_eq_card, Multiset.card_map, Finset.card] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Ring.GeomSum | {
"line": 77,
"column": 80
} | {
"line": 96,
"column": 46
} | {
"line": 98,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\nx y : R\nh : Commute x y\nn : ℕ\n⊢ (∑ i ∈ range n, (x + y) ^ i * y ^ (n - 1 - i)) * x + y ^ n = (x + y) ^ n",
"ppTerm": "?m.55",
"assigned": true,
"usedConstants": [
"add_mul",
"Distrib.leftDistribClass",
"Eq.mpr",
"Finset.mul_sum",
... | [] | by
let f : ℕ → ℕ → R := fun m i : ℕ => (x + y) ^ i * y ^ (m - 1 - i)
change (∑ i ∈ range n, (f n) i) * x + y ^ n = (x + y) ^ n
induction n with
| zero => rw [range_zero, sum_empty, zero_mul, zero_add, pow_zero, pow_zero]
| succ n ih =>
have f_last : f (n + 1) n = (x + y) ^ n := by
dsimp only [f]
... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 258,
"column": 12
} | {
"line": 258,
"column": 67
} | {
"line": 259,
"column": 2
} | [
{
"pp": "case zero\nR : Type u\ninst✝ : Semiring R\ni : ℕ\n⊢ ((∑ i ∈ range 0, X ^ i).comp (X + 1)).coeff i = ↑(Nat.choose 0 (i + 1))",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Polynomial.instOne",
"Nat.choose",
"Polyn... | [] | dsimp; simp only [zero_comp, coeff_zero, Nat.cast_zero] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 258,
"column": 12
} | {
"line": 258,
"column": 67
} | {
"line": 259,
"column": 2
} | [
{
"pp": "case zero\nR : Type u\ninst✝ : Semiring R\ni : ℕ\n⊢ ((∑ i ∈ range 0, X ^ i).comp (X + 1)).coeff i = ↑(Nat.choose 0 (i + 1))",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Polynomial.instOne",
"Nat.choose",
"Polyn... | [] | dsimp; simp only [zero_comp, coeff_zero, Nat.cast_zero] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 310,
"column": 4
} | {
"line": 311,
"column": 7
} | {
"line": 312,
"column": 2
} | [
{
"pp": "case pos\nR : Type u\ninst✝ : Ring R\np : R[X]\nn : ℕ\nh : p.coeff n = 0\n⊢ ↑0 = p.coeff n",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Subring.instSetLike",
"Ring.toNonAssocRing",
"congrArg",
"Finset",
"AddMonoid.toAddZeroClass",
... | [] | rw [h]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 310,
"column": 4
} | {
"line": 311,
"column": 7
} | {
"line": 312,
"column": 2
} | [
{
"pp": "case pos\nR : Type u\ninst✝ : Ring R\np : R[X]\nn : ℕ\nh : p.coeff n = 0\n⊢ ↑0 = p.coeff n",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Subring.instSetLike",
"Ring.toNonAssocRing",
"congrArg",
"Finset",
"AddMonoid.toAddZeroClass",
... | [] | rw [h]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Ring.GeomSum | {
"line": 295,
"column": 2
} | {
"line": 295,
"column": 97
} | {
"line": 297,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝ : Ring R\nx : R\nm n : ℕ\nhmn : m ≤ n\n⊢ (∑ i ∈ Ico m n, x ^ i) * (1 - x) = x ^ m - x ^ n",
"ppTerm": "?m.38",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
"congrArg",
... | [] | rw [sum_Ico_eq_sub _ hmn, sub_mul, geom_sum_mul_neg, geom_sum_mul_neg, sub_sub_sub_cancel_left] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Ring.GeomSum | {
"line": 295,
"column": 2
} | {
"line": 295,
"column": 97
} | {
"line": 297,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝ : Ring R\nx : R\nm n : ℕ\nhmn : m ≤ n\n⊢ (∑ i ∈ Ico m n, x ^ i) * (1 - x) = x ^ m - x ^ n",
"ppTerm": "?m.38",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
"congrArg",
... | [] | rw [sum_Ico_eq_sub _ hmn, sub_mul, geom_sum_mul_neg, geom_sum_mul_neg, sub_sub_sub_cancel_left] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Ring.GeomSum | {
"line": 295,
"column": 2
} | {
"line": 295,
"column": 97
} | {
"line": 297,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝ : Ring R\nx : R\nm n : ℕ\nhmn : m ≤ n\n⊢ (∑ i ∈ Ico m n, x ^ i) * (1 - x) = x ^ m - x ^ n",
"ppTerm": "?m.38",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
"congrArg",
... | [] | rw [sum_Ico_eq_sub _ hmn, sub_mul, geom_sum_mul_neg, geom_sum_mul_neg, sub_sub_sub_cancel_left] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 416,
"column": 2
} | {
"line": 435,
"column": 73
} | {
"line": 437,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nI : Ideal R\nf : R[X]\n⊢ f ∈ map C I ↔ ∀ (n : ℕ), f.coeff n ∈ I",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Submodule",
"SetLike.mem_coe._simp_1",
"Submodule.addSubmonoidClass",
... | [] | constructor
· intro hf
refine Submodule.span_induction ?_ ?_ ?_ ?_ hf
· intro f hf n
obtain ⟨x, hx⟩ := (Set.mem_image _ _ _).mp hf
rw [← hx.right, coeff_C]
by_cases h : n = 0
· simpa [h] using hx.left
· simp [h]
· simp
· exact fun f g _ _ hf hg n => by simp [I.add_mem (hf... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 416,
"column": 2
} | {
"line": 435,
"column": 73
} | {
"line": 437,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nI : Ideal R\nf : R[X]\n⊢ f ∈ map C I ↔ ∀ (n : ℕ), f.coeff n ∈ I",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Submodule",
"SetLike.mem_coe._simp_1",
"Submodule.addSubmonoidClass",
... | [] | constructor
· intro hf
refine Submodule.span_induction ?_ ?_ ?_ ?_ hf
· intro f hf n
obtain ⟨x, hx⟩ := (Set.mem_image _ _ _).mp hf
rw [← hx.right, coeff_C]
by_cases h : n = 0
· simpa [h] using hx.left
· simp [h]
· simp
· exact fun f g _ _ hf hg n => by simp [I.add_mem (hf... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Adjoin.Tower | {
"line": 91,
"column": 2
} | {
"line": 91,
"column": 48
} | {
"line": 92,
"column": 2
} | [
{
"pp": "A : Type w\nB : Type u₁\nC : Type u_1\ninst✝⁶ : CommSemiring A\ninst✝⁵ : CommSemiring B\ninst✝⁴ : Semiring C\ninst✝³ : Algebra A B\ninst✝² : Algebra B C\ninst✝¹ : Algebra A C\ninst✝ : IsScalarTower A B C\nx : Finset C\nhx : Algebra.adjoin A ↑x = ⊤\ny : Finset C\nhy this : span B ↑y = ⊤\n⊢ ∃ B₀, B₀.FG ∧... | [
"A : Type w\nB : Type u₁\nC : Type u_1\ninst✝⁶ : CommSemiring A\ninst✝⁵ : CommSemiring B\ninst✝⁴ : Semiring C\ninst✝³ : Algebra A B\ninst✝² : Algebra B C\ninst✝¹ : Algebra A C\ninst✝ : IsScalarTower A B C\nx : Finset C\nhx : Algebra.adjoin A ↑x = ⊤\ny : Finset C\nhy : span B ↑y = ⊤\nthis : ∀ (x : C), ∃ f, Function.... | simp_rw [eq_top_iff', mem_span_finset] at this | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.RingTheory.Polynomial.Basic | {
"line": 611,
"column": 6
} | {
"line": 611,
"column": 15
} | {
"line": 612,
"column": 4
} | [
{
"pp": "case h\nR : Type u\ninst✝ : CommRing R\nP : Ideal R\nh : P.IsPrime\n⊢ ¬P = ⊤",
"ppTerm": "?h",
"assigned": true,
"usedConstants": [
"CommSemiring.toSemiring",
"CommRing.toCommSemiring",
"Ideal.IsPrime.ne_top'"
],
"usedFVars": [
"R",
"inst✝",
"P",
... | [] | exact h.1 | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Ring.Subsemiring.MulOpposite | {
"line": 146,
"column": 11
} | {
"line": 146,
"column": 19
} | {
"line": 146,
"column": 20
} | [
{
"pp": "R : Type u_2\ninst✝ : NonAssocSemiring R\ns : Set R\n⊢ (closure s).op = closure (MulOpposite.unop ⁻¹' s)",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Subsemiring.closure",
"MulOpposite",
"id",
"Subsemiring",
"Set.preimage",
"Subsemiring.op",... | [
"R : Type u_2\ninst✝ : NonAssocSemiring R\ns : Set R\n⊢ (sInf {S | s ⊆ ↑S}).op = sInf {S | MulOpposite.unop ⁻¹' s ⊆ ↑S}"
] | closure, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Ring.Subring.MulOpposite | {
"line": 140,
"column": 11
} | {
"line": 140,
"column": 19
} | {
"line": 140,
"column": 20
} | [
{
"pp": "R : Type u_2\ninst✝ : NonAssocRing R\ns : Set R\n⊢ (closure s).op = closure (MulOpposite.unop ⁻¹' s)",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"MulOpposite",
"id",
"MulOpposite.instNonAssocRing",
"Set.preimage",
"Subring",
"Subring.op",
... | [
"R : Type u_2\ninst✝ : NonAssocRing R\ns : Set R\n⊢ (sInf {S | s ⊆ ↑S}).op = sInf {S | MulOpposite.unop ⁻¹' s ⊆ ↑S}"
] | closure, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.RingTheory.FiniteType | {
"line": 114,
"column": 85
} | {
"line": 119,
"column": 37
} | {
"line": 121,
"column": 0
} | [
{
"pp": "R : Type uR\nS : Type uS\nA : Type uA\nB : Type uB\nM : Type uM\nN : Type uN\ninst✝¹² : CommSemiring R\ninst✝¹¹ : CommSemiring S\ninst✝¹⁰ : Semiring A\ninst✝⁹ : Semiring B\ninst✝⁸ : Algebra R S\ninst✝⁷ : Algebra R A\ninst✝⁶ : Algebra R B\ninst✝⁵ : AddCommMonoid M\ninst✝⁴ : Module R M\ninst✝³ : AddCommM... | [] | by
classical
cases nonempty_fintype ι
refine .trans ‹_› ⟨Finset.univ.image (FreeAlgebra.ι _), ?_⟩
rw [Finset.coe_image, Finset.coe_univ, Set.image_univ]
exact FreeAlgebra.adjoin_range_ι .. | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.FiniteType | {
"line": 558,
"column": 78
} | {
"line": 576,
"column": 33
} | {
"line": 578,
"column": 0
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝¹ : Monoid M\ninst✝ : CommSemiring R\nS : Set M\nhS : closure S = ⊤\n⊢ Surjective ⇑((FreeAlgebra.lift R) fun s ↦ (of R M) ↑s)",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"MonoidAlgebra.semiring",
"Eq.mpr",
"FreeAlgebra.ι",
... | [] | by
intro f
induction f using induction_on with
| hM m =>
have : m ∈ closure S := hS.symm ▸ mem_top _
refine Submonoid.closure_induction (fun m hm => ?_) ?_ ?_ this
· exact ⟨FreeAlgebra.ι R ⟨m, hm⟩, FreeAlgebra.lift_ι_apply _ _⟩
· exact ⟨1, map_one _⟩
· rintro m₁ m₂ _ _ ⟨P₁, hP₁⟩ ⟨P₂, hP₂⟩
... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Ideal.Quotient.Operations | {
"line": 357,
"column": 18
} | {
"line": 357,
"column": 30
} | {
"line": 357,
"column": 30
} | [
{
"pp": "R : Type u\nS : Type v\nF : Type w\ninst✝⁷ : Ring R\ninst✝⁶ : Semiring S\nR₁ : Type u_1\nR₂ : Type u_2\nA : Type u_3\nB : Type u_4\ninst✝⁵ : CommSemiring R₁\ninst✝⁴ : CommSemiring R₂\ninst✝³ : Ring A\ninst✝² : Algebra R₁ A\ninst✝¹ : Algebra R₂ A\nI : Ideal A\ninst✝ : I.IsTwoSided\n⊢ ∀ (r : R₁) (x : A ⧸... | [
"case mk\nR : Type u\nS : Type v\nF : Type w\ninst✝⁷ : Ring R\ninst✝⁶ : Semiring S\nR₁ : Type u_1\nR₂ : Type u_2\nA : Type u_3\nB : Type u_4\ninst✝⁵ : CommSemiring R₁\ninst✝⁴ : CommSemiring R₂\ninst✝³ : Ring A\ninst✝² : Algebra R₁ A\ninst✝¹ : Algebra R₂ A\nI : Ideal A\ninst✝ : I.IsTwoSided\nr : R₁\nx✝ : A ⧸ I\nx : ... | rintro r ⟨x⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.RingTheory.Ideal.Quotient.Operations | {
"line": 504,
"column": 2
} | {
"line": 504,
"column": 29
} | {
"line": 506,
"column": 0
} | [
{
"pp": "R₁ : Type u_1\nA : Type u_3\nB : Type u_4\ninst✝⁴ : CommSemiring R₁\ninst✝³ : Ring A\ninst✝² : Algebra R₁ A\ninst✝¹ : Semiring B\ninst✝ : Algebra R₁ B\nf : A →ₐ[R₁] B\nr : R₁\na : A\n⊢ f.kerLift (r • (Quotient.mkₐ R₁ (ker f)) a) = r • f.kerLift ((Quotient.mkₐ R₁ (ker f)) a)",
"ppTerm": "?m.62",
... | [] | exact _root_.map_smul f _ _ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.List.Permutation | {
"line": 220,
"column": 64
} | {
"line": 221,
"column": 40
} | {
"line": 223,
"column": 0
} | [
{
"pp": "α : Type u_1\n⊢ [].permutations = [[]]",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"List.permutationsAux_nil",
"Eq.mpr",
"congrArg",
"id",
"List.permutations",
"List.cons",
"List",
"Eq.refl",
"List.permutations.eq_1",
... | [] | by
rw [permutations, permutationsAux_nil] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Dynamics.PeriodicPts.Defs | {
"line": 594,
"column": 8
} | {
"line": 594,
"column": 17
} | {
"line": 594,
"column": 18
} | [
{
"pp": "α : Type v\nG : Type u\ninst✝¹ : Group G\ninst✝ : MulAction G α\nj : ℤ\ng : G\na : α\nn : ℕ\n⊢ g ^ (-↑(n + 1)) • a = a ↔ ↑(period g a) ∣ -↑(n + 1)",
"ppTerm": "?m.31",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"instHSMul",
"Dvd.dvd",
"DivInvOneMonoid.toInvOneCla... | [
"α : Type v\nG : Type u\ninst✝¹ : Group G\ninst✝ : MulAction G α\nj : ℤ\ng : G\na : α\nn : ℕ\n⊢ (g ^ ↑(n + 1))⁻¹ • a = a ↔ ↑(period g a) ∣ -↑(n + 1)"
] | zpow_neg, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Cycle | {
"line": 88,
"column": 97
} | {
"line": 93,
"column": 58
} | {
"line": 95,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nxs : List α\nx d : α\nh : x ∉ xs\n⊢ (xs ++ [x]).nextOr x d = d",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"List.nextOr",
"Iff.mpr",
"Eq.mpr",
"congrArg",
"Membership.mem",
"mt",
"List.nextOr_cons_o... | [] | by
induction xs with
| nil => simp
| cons z zs IH =>
obtain ⟨hz, hzs⟩ := not_or.mp (mt mem_cons.2 h)
rw [cons_append, nextOr_cons_of_ne _ _ _ _ hz, IH hzs] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.GroupAction.Basic | {
"line": 287,
"column": 2
} | {
"line": 287,
"column": 45
} | {
"line": 289,
"column": 0
} | [
{
"pp": "G : Type u_1\nα : Type u_2\ninst✝¹ : Group G\ninst✝ : MulAction G α\na : α\n⊢ stabilizerEquivStabilizer ⋯ = MulEquiv.refl ↥(stabilizer G a)",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"MulAction.stabilizerEquivStabilizer",
"MonoidHom.instMonoidHomClass",
"Mul... | [] | ext; simp [stabilizerEquivStabilizer_apply] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.GroupAction.Basic | {
"line": 287,
"column": 2
} | {
"line": 287,
"column": 45
} | {
"line": 289,
"column": 0
} | [
{
"pp": "G : Type u_1\nα : Type u_2\ninst✝¹ : Group G\ninst✝ : MulAction G α\na : α\n⊢ stabilizerEquivStabilizer ⋯ = MulEquiv.refl ↥(stabilizer G a)",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"MulAction.stabilizerEquivStabilizer",
"MonoidHom.instMonoidHomClass",
"Mul... | [] | ext; simp [stabilizerEquivStabilizer_apply] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Cycle | {
"line": 390,
"column": 59
} | {
"line": 392,
"column": 32
} | {
"line": 394,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nl : List α\nh : l.Nodup\nx : α\nhx : x ∈ l\n⊢ l.reverse.next x ⋯ = l.prev x hx",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"List.nodup_reverse",
"HEq.refl",
"Membership.mem",
"Eq.case... | [] | by
convert! (prev_reverse_eq_next l.reverse (nodup_reverse.mpr h) x (mem_reverse.mpr hx)).symm
exact (reverse_reverse l).symm | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Cycle | {
"line": 760,
"column": 93
} | {
"line": 761,
"column": 31
} | {
"line": 763,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Cycle α\nhs : s.Nodup\nx : α\nhx : x ∈ s\n⊢ s.reverse.next ⋯ x ⋯ = s.prev hs x hx",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Cycle.nodup_reverse_iff",
"Cycle.mem_reverse_iff",
"congrArg",
"Memb... | [] | by
simp [← prev_reverse_eq_next] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Cycle | {
"line": 765,
"column": 91
} | {
"line": 766,
"column": 31
} | {
"line": 768,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\ns : Cycle α\nhs : s.reverse.Nodup\nx : α\nhx : x ∈ s.reverse\n⊢ s.reverse.next hs x hx = s.prev ⋯ x ⋯",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Cycle.nodup_reverse_iff",
"Cycle.mem_reverse_iff",
"congrA... | [] | by
simp [← prev_reverse_eq_next] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Index | {
"line": 240,
"column": 2
} | {
"line": 240,
"column": 30
} | {
"line": 241,
"column": 2
} | [
{
"pp": "case neg\nG : Type u_1\ninst✝ : Group G\nH : Subgroup G\nh : H.index = 2\na b : G\nha : a ∉ H\nhb : b ∉ H\n⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"HMul.hMul",
"eq_false",
"Monoid.toMulOneClass"... | [
"case neg\nG : Type u_1\ninst✝ : Group G\nH : Subgroup G\nh : H.index = 2\na b : G\nha : a ∉ H\nhb : b ∉ H\n⊢ a * b ∈ H"
] | simp only [ha, hb, iff_true] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.GroupTheory.Index | {
"line": 269,
"column": 6
} | {
"line": 269,
"column": 52
} | {
"line": 269,
"column": 53
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\n⊢ H.relIndex ⊤ = H.index",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Subgroup.relIndex_mul_index",
"HMul.hMul",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Complete... | [
"G : Type u_1\ninst✝ : Group G\nH : Subgroup G\n⊢ H.relIndex ⊤ = H.relIndex ⊤ * ⊤.index"
] | ← relIndex_mul_index (show H ≤ ⊤ from le_top), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Index | {
"line": 732,
"column": 2
} | {
"line": 732,
"column": 28
} | {
"line": 734,
"column": 0
} | [
{
"pp": "G : Type u_1\nG' : Type u_2\ninst✝³ : Group G\ninst✝² : Group G'\nH K L : Subgroup G\nf : G →* G'\ninst✝¹ : H.FiniteIndex\ninst✝ : K.FiniteIndex\n⊢ (H.prod K).FiniteIndex",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"False",
"Nat.instMulZeroClass",
"IsDomain.t... | [] | simp_all [finiteIndex_iff] | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.GroupTheory.Index | {
"line": 732,
"column": 2
} | {
"line": 732,
"column": 28
} | {
"line": 734,
"column": 0
} | [
{
"pp": "G : Type u_1\nG' : Type u_2\ninst✝³ : Group G\ninst✝² : Group G'\nH K L : Subgroup G\nf : G →* G'\ninst✝¹ : H.FiniteIndex\ninst✝ : K.FiniteIndex\n⊢ (H.prod K).FiniteIndex",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"False",
"Nat.instMulZeroClass",
"IsDomain.t... | [] | simp_all [finiteIndex_iff] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Index | {
"line": 732,
"column": 2
} | {
"line": 732,
"column": 28
} | {
"line": 734,
"column": 0
} | [
{
"pp": "G : Type u_1\nG' : Type u_2\ninst✝³ : Group G\ninst✝² : Group G'\nH K L : Subgroup G\nf : G →* G'\ninst✝¹ : H.FiniteIndex\ninst✝ : K.FiniteIndex\n⊢ (H.prod K).FiniteIndex",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"False",
"Nat.instMulZeroClass",
"IsDomain.t... | [] | simp_all [finiteIndex_iff] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Divisors | {
"line": 66,
"column": 34
} | {
"line": 66,
"column": 39
} | {
"line": 68,
"column": 0
} | [
{
"pp": "n x₁ x₂ : ℕ\nx✝ : ℕ × ℕ\nx y : ℕ\nhx₁ :\n (x, y) ∈\n let y := n / x₁;\n if x₁ * y = n then some (x₁, y) else none\nhx₂ :\n (x, y) ∈\n let y := n / x₂;\n if x₂ * y = n then some (x₂, y) else none\n⊢ x₁ = x₂",
"ppTerm": "?m.51",
"assigned": true,
"usedConstants": [
"instHD... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.NumberTheory.Divisors | {
"line": 66,
"column": 34
} | {
"line": 66,
"column": 39
} | {
"line": 68,
"column": 0
} | [
{
"pp": "n x₁ x₂ : ℕ\nx✝ : ℕ × ℕ\nx y : ℕ\nhx₁ :\n (x, y) ∈\n let y := n / x₁;\n if x₁ * y = n then some (x₁, y) else none\nhx₂ :\n (x, y) ∈\n let y := n / x₂;\n if x₂ * y = n then some (x₂, y) else none\n⊢ x₁ = x₂",
"ppTerm": "?m.51",
"assigned": true,
"usedConstants": [
"instHD... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Divisors | {
"line": 66,
"column": 34
} | {
"line": 66,
"column": 39
} | {
"line": 68,
"column": 0
} | [
{
"pp": "n x₁ x₂ : ℕ\nx✝ : ℕ × ℕ\nx y : ℕ\nhx₁ :\n (x, y) ∈\n let y := n / x₁;\n if x₁ * y = n then some (x₁, y) else none\nhx₂ :\n (x, y) ∈\n let y := n / x₂;\n if x₂ * y = n then some (x₂, y) else none\n⊢ x₁ = x₂",
"ppTerm": "?m.51",
"assigned": true,
"usedConstants": [
"instHD... | [] | aesop | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Divisors | {
"line": 217,
"column": 2
} | {
"line": 220,
"column": 40
} | {
"line": 222,
"column": 0
} | [
{
"pp": "n m : ℕ\n⊢ n ∈ m.divisors → n ≤ m",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Nat.mem_divisors._simp_1",
"Eq.mpr",
"False",
"Nat.instMulZeroClass",
"Dvd.dvd",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"eq_false",
"and_t... | [] | rcases m with - | m
· simp
· simp only [mem_divisors, Nat.succ_ne_zero m, and_true, Ne, not_false_iff]
exact Nat.le_of_dvd (Nat.succ_pos m) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Divisors | {
"line": 217,
"column": 2
} | {
"line": 220,
"column": 40
} | {
"line": 222,
"column": 0
} | [
{
"pp": "n m : ℕ\n⊢ n ∈ m.divisors → n ≤ m",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Nat.mem_divisors._simp_1",
"Eq.mpr",
"False",
"Nat.instMulZeroClass",
"Dvd.dvd",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"eq_false",
"and_t... | [] | rcases m with - | m
· simp
· simp only [mem_divisors, Nat.succ_ne_zero m, and_true, Ne, not_false_iff]
exact Nat.le_of_dvd (Nat.succ_pos m) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Divisors | {
"line": 228,
"column": 4
} | {
"line": 229,
"column": 39
} | {
"line": 230,
"column": 2
} | [
{
"pp": "n : ℕ\n⊢ #n.divisors ≤ #(Ico 1 (n + 1))",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Dvd.dvd",
"Nat.decidable_dvd",
"Finset",
"Finset.card_le_card",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Nat.instLocallyFiniteOrder",
"Finse... | [] | apply card_le_card
simp only [divisors, filter_subset] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Divisors | {
"line": 228,
"column": 4
} | {
"line": 229,
"column": 39
} | {
"line": 230,
"column": 2
} | [
{
"pp": "n : ℕ\n⊢ #n.divisors ≤ #(Ico 1 (n + 1))",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Dvd.dvd",
"Nat.decidable_dvd",
"Finset",
"Finset.card_le_card",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Nat.instLocallyFiniteOrder",
"Finse... | [] | apply card_le_card
simp only [divisors, filter_subset] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Cardinal | {
"line": 35,
"column": 2
} | {
"line": 35,
"column": 30
} | {
"line": 37,
"column": 0
} | [
{
"pp": "case inr\nR : Type u\ninst✝ : Semiring R\nh✝ : Nontrivial R\n⊢ #R[X] ≤ max #R ℵ₀",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"Lattice.toSemilatticeSup",
"Cardinal",
"PartialOrder.toPreorder",
"Cardinal.mk",
"SemilatticeSup.toMax",
"Eq.le",
... | [] | · exact cardinalMk_eq_max.le | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.ZMod.Basic | {
"line": 459,
"column": 2
} | {
"line": 460,
"column": 17
} | {
"line": 462,
"column": 0
} | [
{
"pp": "a b : ℕ\nhab : a = b\n⊢ (ringEquivCongr hab).symm = ringEquivCongr ⋯",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"ZMod.commRing",
"CommSemiring.toSemiring",
"ZMod.ringEquivCongr",
"Eq.rec",
"Distrib.toAdd",
"instOfNatNat",
"ZMod",
... | [] | subst hab
cases a <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ZMod.Basic | {
"line": 459,
"column": 2
} | {
"line": 460,
"column": 17
} | {
"line": 462,
"column": 0
} | [
{
"pp": "a b : ℕ\nhab : a = b\n⊢ (ringEquivCongr hab).symm = ringEquivCongr ⋯",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"ZMod.commRing",
"CommSemiring.toSemiring",
"ZMod.ringEquivCongr",
"Eq.rec",
"Distrib.toAdd",
"instOfNatNat",
"ZMod",
... | [] | subst hab
cases a <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Divisors | {
"line": 473,
"column": 44
} | {
"line": 473,
"column": 67
} | {
"line": 475,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : CommMonoid α\np : ℕ\nf : ℕ → α\nh : Prime p\n⊢ ∏ x ∈ p.properDivisors, f x = f 1",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Finset.prod_singleton",
"congrArg",
"Finset",
"Nat.Prime.properDivisors",
"Membership.mem",
"i... | [] | simp [h.properDivisors] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.NumberTheory.Divisors | {
"line": 473,
"column": 44
} | {
"line": 473,
"column": 67
} | {
"line": 475,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : CommMonoid α\np : ℕ\nf : ℕ → α\nh : Prime p\n⊢ ∏ x ∈ p.properDivisors, f x = f 1",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Finset.prod_singleton",
"congrArg",
"Finset",
"Nat.Prime.properDivisors",
"Membership.mem",
"i... | [] | simp [h.properDivisors] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Divisors | {
"line": 473,
"column": 44
} | {
"line": 473,
"column": 67
} | {
"line": 475,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : CommMonoid α\np : ℕ\nf : ℕ → α\nh : Prime p\n⊢ ∏ x ∈ p.properDivisors, f x = f 1",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Finset.prod_singleton",
"congrArg",
"Finset",
"Nat.Prime.properDivisors",
"Membership.mem",
"i... | [] | simp [h.properDivisors] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.ZMod.Basic | {
"line": 774,
"column": 43
} | {
"line": 776,
"column": 51
} | {
"line": 778,
"column": 0
} | [
{
"pp": "n x : ℕ\nh : x.Coprime n\n⊢ ↑x * (↑x)⁻¹ = 1",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
"Nat.Coprime",
"HMul.hMul",
"ZMod.instInv",
"ZMod.commRing",
"congrArg",
"CommSemiring.toSemiring",
"AddGroupWithO... | [] | by
rw [Nat.Coprime, Nat.gcd_comm, Nat.gcd_rec] at h
rw [mul_inv_eq_gcd, val_natCast, h, Nat.cast_one] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.ZMod.Basic | {
"line": 900,
"column": 8
} | {
"line": 902,
"column": 84
} | {
"line": 903,
"column": 4
} | [
{
"pp": "case inr.right\nm n : ℕ\nh : Nat.Coprime 1 0\nto_fun : ZMod (1 * 0) → ZMod 1 × ZMod 0 := ⋯\ninv_fun : ZMod 1 × ZMod 0 → ZMod (1 * 0) := ⋯\nhmn0 : 1 * 0 = 0\n⊢ RightInverse inv_fun to_fun",
"ppTerm": "?inr.right",
"assigned": true,
"usedConstants": [
"instNeZeroNatHAdd_1",
"Prod.... | [] | · rintro ⟨x, y⟩
fin_cases x
simp [to_fun, inv_fun, castHom, Prod.ext_iff, eq_iff_true_of_subsingleton] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.ZMod.Basic | {
"line": 910,
"column": 8
} | {
"line": 910,
"column": 50
} | {
"line": 911,
"column": 8
} | [
{
"pp": "m✝ n✝ m n : ℕ\nh : m.Coprime n\nto_fun : ZMod (m * n) → ZMod m × ZMod n := ⇑(castHom ⋯ (ZMod m × ZMod n))\ninv_fun : ZMod m × ZMod n → ZMod (m * n) :=\n fun x ↦\n if m * n = 0 then\n if m = 1 then ((RingHom.snd (ZMod m) (ZMod n)) x).cast else ((RingHom.fst (ZMod m) (ZMod n)) x).cast\n else ... | [
"m✝ n✝ m n : ℕ\nh : m.Coprime n\nto_fun : ZMod (m * n) → ZMod m × ZMod n := ⇑(castHom ⋯ (ZMod m × ZMod n))\ninv_fun : ZMod m × ZMod n → ZMod (m * n) :=\n fun x ↦\n if m * n = 0 then\n if m = 1 then ((RingHom.snd (ZMod m) (ZMod n)) x).cast else ((RingHom.fst (ZMod m) (ZMod n)) x).cast\n else ↑↑(Nat.chine... | conv_rhs => rw [← ZMod.natCast_zmod_val x] | Mathlib.Tactic.Conv._aux_Mathlib_Tactic_Conv___macroRules_Mathlib_Tactic_Conv_convRHS_1 | Mathlib.Tactic.Conv.convRHS |
Mathlib.Data.Nat.Choose.Bounds | {
"line": 86,
"column": 8
} | {
"line": 86,
"column": 30
} | {
"line": 87,
"column": 8
} | [
{
"pp": "case neg.succ.zero\nn : ℕ\nlt : ¬n + 1 + 1 < 0\n⊢ (n + 1 + 1).choose 0 ≤ 2 ^ (n + 1)",
"ppTerm": "?neg.succ.zero✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"congrArg",
"Nat.instMonoid",
"id",
"instOfNatNat",
"LE.le",
"inst... | [
"case neg.succ.zero\nn : ℕ\nlt : ¬n + 1 + 1 < 0\n⊢ 1 ≤ 2 ^ (n + 1)"
] | rw [choose_zero_right] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.NumberTheory.Divisors | {
"line": 760,
"column": 2
} | {
"line": 760,
"column": 7
} | {
"line": 762,
"column": 0
} | [
{
"pp": "a b : ℤ\n⊢ (a, b) ∈ divisorsAntidiag 1 ∨ (a, b) ∈ divisorsAntidiag 2 ∨ (a, b) ∈ divisorsAntidiag 3 ↔\n (a, b) = (1, 1) ∨\n (a, b) = (-1, -1) ∨\n (a, b) = (1, 2) ∨\n (a, b) = (2, 1) ∨\n (a, b) = (-1, -2) ∨\n (a, b) = (-2, -1) ∨ (a, b) = (1, 3) ∨ (a, b) = (... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.NumberTheory.Divisors | {
"line": 772,
"column": 2
} | {
"line": 772,
"column": 7
} | {
"line": 774,
"column": 0
} | [
{
"pp": "a b : ℤ\nh₀ : a = 0 ↔ b = 0\n⊢ a * b = 0 ∨\n (a, b) ∈ divisorsAntidiag 1 ∨\n (a, b) ∈ divisorsAntidiag 2 ∨ (a, b) ∈ divisorsAntidiag 3 ∨ (a, b) ∈ divisorsAntidiag 4 ↔\n (a, b) = (0, 0) ∨\n (a, b) = (1, 1) ∨\n (a, b) = (-1, -1) ∨\n (a, b) = (1, 2) ∨\n (a, b... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 59,
"column": 4
} | {
"line": 59,
"column": 9
} | {
"line": 60,
"column": 2
} | [
{
"pp": "case pos\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⊢ n < b ∨ b ≤ 1",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"not_lt_zero._simp_1",
"False",
"Nat.instMulZeroClass",
"instHDiv",
... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 106,
"column": 6
} | {
"line": 106,
"column": 50
} | {
"line": 107,
"column": 6
} | [
{
"pp": "case pos\nb m n : ℕ\nhb✝ : 0 < b\nhb : succ 0 < b\nh_append : b.digits n ++ b.digits m ≠ []\nh : b.digits m = []\n⊢ (b.digits n ++ b.digits m).getLast h_append ≠ 0",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"List.getLast",
"Eq.mpr",
"congrArg",
"Eq.mp"... | [
"case pos\nb m n : ℕ\nhb✝ : 0 < b\nhb : succ 0 < b\nh_append✝ : b.digits n ++ b.digits m ≠ []\nh : b.digits m = []\nh_append : b.digits n ≠ []\n⊢ (b.digits n).getLast ⋯ ≠ 0"
] | simp only [h, List.append_nil] at h_append ⊢ | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Nat.Digits.Defs | {
"line": 535,
"column": 6
} | {
"line": 535,
"column": 17
} | {
"line": 536,
"column": 8
} | [
{
"pp": "case succ.succ.succ\nb f : ℕ\nih : ∀ (n e : ℕ), 0 < e → n < b ^ e → (b.toDigitsCore f n []).length ≤ e\nn e : ℕ\nh_e_pos : 0 < e + 1 + 1\nhlt : n < b ^ (e + 1 + 1)\n⊢ (if n / b = 0 then [(n % b).digitChar] else b.toDigitsCore f (n / b) [(n % b).digitChar]).length ≤ e + 1 + 1",
"ppTerm": "?succ.succ... | [] | | succ e => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | null |
Mathlib.Data.Nat.Digits.Defs | {
"line": 530,
"column": 4
} | {
"line": 530,
"column": 15
} | {
"line": 531,
"column": 6
} | [
{
"pp": "case succ.succ\nb f : ℕ\nih : ∀ (n e : ℕ), 0 < e → n < b ^ e → (b.toDigitsCore f n []).length ≤ e\nn e : ℕ\nh_e_pos : 0 < e + 1\nhlt : n < b ^ (e + 1)\n⊢ (if n / b = 0 then [(n % b).digitChar] else b.toDigitsCore f (n / b) [(n % b).digitChar]).length ≤ e + 1",
"ppTerm": "?succ.succ",
"assigned"... | [] | | succ e => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | null |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 53,
"column": 41
} | {
"line": 53,
"column": 46
} | {
"line": 55,
"column": 0
} | [
{
"pp": "a b m n✝ p n : ℕ\n⊢ ∀ (a : ℕ), Prime a → (a ∣ n ∧ ¬n = 0 ↔ ¬a = 1 ∧ ¬n = 0 ∧ a ∣ n)",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"Nat.Prime",
"Dvd.dvd",
"eq_false",
"and_true",
"congrArg",
"and_self",
"Fal... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 148,
"column": 2
} | {
"line": 148,
"column": 40
} | {
"line": 149,
"column": 2
} | [
{
"pp": "p r i : ℕ\nhr : ¬p ∣ r\n⊢ (p * i + r).factorization p = 0",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Nat.factorization_eq_zero_of_not_dvd",
"HMul.hMul",
"instMulNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"instHMul"
... | [
"p r i : ℕ\nhr : ¬p ∣ r\n⊢ ¬p ∣ p * i + r"
] | apply factorization_eq_zero_of_not_dvd | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 308,
"column": 2
} | {
"line": 308,
"column": 23
} | {
"line": 308,
"column": 24
} | [
{
"pp": "a b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\np : ℕ\n⊢ p ^ a.factorization p ∣ p ^ b.factorization p ↔ a.factorization p ≤ b.factorization p",
"ppTerm": "?m.44",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Nat.instMulZeroClass",
"Dvd.dvd",
"Nat.instMonoid",
... | [
"case zero\na b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\n⊢ 0 ^ a.factorization 0 ∣ 0 ^ b.factorization 0 ↔ a.factorization 0 ≤ b.factorization 0",
"case succ.zero\na b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\n⊢ (0 + 1) ^ a.factorization (0 + 1) ∣ (0 + 1) ^ b.factorization (0 + 1) ↔\n a.factorization (0 + 1) ≤ b.factorization (0 + 1)"... | obtain _ | _ | p := p | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.GroupTheory.OrderOfElement | {
"line": 86,
"column": 12
} | {
"line": 86,
"column": 21
} | {
"line": 86,
"column": 22
} | [
{
"pp": "case inr\nG : Type u_6\ninst✝ : DivisionMonoid G\nx : G\nx✝ : ∃ n, n ≠ 0 ∧ x ^ n = 1\nn : ℤ\nhn : n ≠ 0\nhn' : x ^ (-↑n.natAbs) = 1\nh : n = -↑n.natAbs\n⊢ x ^ n.natAbs = 1",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClas... | [
"case inr\nG : Type u_6\ninst✝ : DivisionMonoid G\nx : G\nx✝ : ∃ n, n ≠ 0 ∧ x ^ n = 1\nn : ℤ\nhn : n ≠ 0\nhn' : (x ^ ↑n.natAbs)⁻¹ = 1\nh : n = -↑n.natAbs\n⊢ x ^ n.natAbs = 1"
] | zpow_neg, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.OrderOfElement | {
"line": 234,
"column": 4
} | {
"line": 234,
"column": 18
} | {
"line": 235,
"column": 4
} | [
{
"pp": "case neg\nG : Type u_1\ninst✝ : Monoid G\nx : G\nn : ℕ\nh : 0 < n\nh1 : 1 ∉ periodicPts fun x_1 ↦ x * x_1\n⊢ ¬(IsPeriodicPt (fun x_1 ↦ x * x_1) n 1 ∧ ∀ m < n, 0 < m → ¬IsPeriodicPt (fun x_1 ↦ x * x_1) m 1)",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
... | [
"case neg\nG : Type u_1\ninst✝ : Monoid G\nx : G\nn : ℕ\nh : 0 < n\nh1 : 1 ∉ periodicPts fun x_1 ↦ x * x_1\nh' : IsPeriodicPt (fun x_1 ↦ x * x_1) n 1\n⊢ False"
] | rintro ⟨h', -⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Data.Nat.Choose.Factorization | {
"line": 75,
"column": 4
} | {
"line": 75,
"column": 42
} | {
"line": 76,
"column": 4
} | [
{
"pp": "n p : ℕ\nhp : Prime p\nh0 : 2 ≤ p\nh1 : 1 ≤ p * n + 1\nh2 : p * n + 1 ≤ p * (n + 1)\nh3 : p * n + 1 ≤ p * (n + 1) + 1\nm : ℕ\nhm : m ∈ Ico (p * n + 1) (p * (n + 1))\n⊢ m.factorization p = 0",
"ppTerm": "?m.158",
"assigned": true,
"usedConstants": [
"Nat.factorization_eq_zero_of_not_dv... | [
"n p : ℕ\nhp : Prime p\nh0 : 2 ≤ p\nh1 : 1 ≤ p * n + 1\nh2 : p * n + 1 ≤ p * (n + 1)\nh3 : p * n + 1 ≤ p * (n + 1) + 1\nm : ℕ\nhm : m ∈ Ico (p * n + 1) (p * (n + 1))\n⊢ ¬p ∣ m"
] | apply factorization_eq_zero_of_not_dvd | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.GroupTheory.OrderOfElement | {
"line": 548,
"column": 4
} | {
"line": 549,
"column": 17
} | {
"line": 549,
"column": 17
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx : G\np : ℕ\nhp : Fact (Nat.Prime p)\nx✝ : ∃ m, x ^ p ^ m = 1\nw✝ : ℕ\nhm : x ^ p ^ w✝ = 1\n⊢ ∃ k, orderOf x = p ^ k",
"ppTerm": "?m.48",
"assigned": true,
"usedConstants": [
"Nat.Prime",
"Dvd.dvd",
"Nat.instMonoid",
"orderOf_dvd_of_p... | [] | obtain ⟨k, _, hk⟩ := (Nat.dvd_prime_pow hp.elim).mp (orderOf_dvd_of_pow_eq_one hm)
exact ⟨k, hk⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.OrderOfElement | {
"line": 548,
"column": 4
} | {
"line": 549,
"column": 17
} | {
"line": 549,
"column": 17
} | [
{
"pp": "G : Type u_1\ninst✝ : Monoid G\nx : G\np : ℕ\nhp : Fact (Nat.Prime p)\nx✝ : ∃ m, x ^ p ^ m = 1\nw✝ : ℕ\nhm : x ^ p ^ w✝ = 1\n⊢ ∃ k, orderOf x = p ^ k",
"ppTerm": "?m.48",
"assigned": true,
"usedConstants": [
"Nat.Prime",
"Dvd.dvd",
"Nat.instMonoid",
"orderOf_dvd_of_p... | [] | obtain ⟨k, _, hk⟩ := (Nat.dvd_prime_pow hp.elim).mp (orderOf_dvd_of_pow_eq_one hm)
exact ⟨k, hk⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Multiplicity | {
"line": 145,
"column": 8
} | {
"line": 145,
"column": 15
} | {
"line": 145,
"column": 15
} | [
{
"pp": "n p : ℕ\nhp : Prime p\nhp' : _root_.Prime p\nh0 : 2 ≤ p\nh1 : 1 ≤ p * n + 1\nh2 : p * n + 1 ≤ p * (n + 1)\nh3 : p * n + 1 ≤ p * (n + 1) + 1\nm : ℕ\nhm : m ∈ Ico (p * n + 1) (p * (n + 1))\n⊢ ∃ k, p * k < m ∧ m < p * (k + 1)",
"ppTerm": "?m.213",
"assigned": true,
"usedConstants": [
"Pr... | [
"n p : ℕ\nhp : Prime p\nhp' : _root_.Prime p\nh0 : 2 ≤ p\nh1 : 1 ≤ p * n + 1\nh2 : p * n + 1 ≤ p * (n + 1)\nh3 : p * n + 1 ≤ p * (n + 1) + 1\nm : ℕ\nhm : p * n + 1 ≤ m ∧ m < p * (n + 1)\n⊢ ∃ k, p * k < m ∧ m < p * (k + 1)"
] | mem_Ico | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Choose.Factorization | {
"line": 174,
"column": 17
} | {
"line": 174,
"column": 78
} | {
"line": 174,
"column": 78
} | [
{
"pp": "p n k : ℕ\nhp : Prime p\nhkn : k ≤ p ^ n\nhk0 : k ≠ 0\n⊢ ((p ^ n).choose k).factorization p = n - k.factorization p",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instMulZeroClass",
"Nat.choose",
"congrArg",
... | [
"p n k : ℕ\nhp : Prime p\nhkn : k ≤ p ^ n\nhk0 : k ≠ 0\n⊢ ((p ^ n).choose k).factorization p = ((p ^ n).choose k).factorization p + k.factorization p - k.factorization p"
] | ← factorization_choose_prime_pow_add_factorization hp hkn hk0 | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.OrderOfElement | {
"line": 690,
"column": 4
} | {
"line": 692,
"column": 31
} | {
"line": 694,
"column": 0
} | [
{
"pp": "case mpr\nG : 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",
"ppTerm": "?mpr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Trans.trans",
"HMul.hMu... | [] | calc
x ^ (m + k) = x ^ m * x ^ k := by rw [pow_add]
_ = x ^ m := by simp [hk] | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcTactic |
Mathlib.GroupTheory.OrderOfElement | {
"line": 771,
"column": 42
} | {
"line": 771,
"column": 51
} | {
"line": 771,
"column": 52
} | [
{
"pp": "case inr\nG : Type u_1\ninst✝ : Group G\nx : G\ni : ℕ\n⊢ orderOf x ∣ i ↔ x ^ (-↑i) = 1",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"congrArg",
"DivInvMonoid.toZPow",
... | [
"case inr\nG : Type u_1\ninst✝ : Group G\nx : G\ni : ℕ\n⊢ orderOf x ∣ i ↔ (x ^ ↑i)⁻¹ = 1"
] | zpow_neg, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Multiplicity | {
"line": 250,
"column": 68
} | {
"line": 256,
"column": 31
} | {
"line": 258,
"column": 0
} | [
{
"pp": "p n k : ℕ\nhp : Prime p\nhkn : k ≤ p ^ n\nhk0 : k ≠ 0\n⊢ emultiplicity p ((p ^ n).choose k) = ↑(n - multiplicity p k)",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Nat.Prime.emultiplicity_choose_prime_pow_add_emultiplicity",
"Iff.mpr",
"Eq.mpr",
"Nat.add... | [] | by
push_cast
rw [← emultiplicity_choose_prime_pow_add_emultiplicity hp hkn hk0,
(finiteMultiplicity_iff.2 ⟨hp.ne_one, Nat.pos_of_ne_zero hk0⟩).emultiplicity_eq_multiplicity,
(finiteMultiplicity_iff.2 ⟨hp.ne_one, choose_pos hkn⟩).emultiplicity_eq_multiplicity]
norm_cast
rw [Nat.add_sub_cancel_right] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Div | {
"line": 112,
"column": 69
} | {
"line": 112,
"column": 78
} | {
"line": 112,
"column": 78
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\np q : R[X]\nh : q.degree ≤ p.degree ∧ p ≠ 0\nhq : q.Monic\nhp : p.leadingCoeff ≠ 0\nhq0 : q ≠ 0\n⊢ q.degree ≤ p.degree",
"ppTerm": "?m.118",
"assigned": true,
"usedConstants": [
"WithBot.instPreorder",
"WithBot",
"Preorder.toLE",
"Ne",
... | [] | exact h.1 | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Polynomial.Div | {
"line": 177,
"column": 4
} | {
"line": 178,
"column": 65
} | {
"line": 180,
"column": 0
} | [
{
"pp": "case neg\nR : Type u\ninst✝ : Ring R\np q : R[X]\nhmq : q.Monic\nhq : q ≠ 1\nhpq : ¬p %ₘ q = 0\n⊢ (p %ₘ q).natDegree < q.natDegree",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Polynomial",
"Polynomial.Nontrivial.of_polynomial_ne",
"Polynomial.modByMonic",
... | [] | haveI := Nontrivial.of_polynomial_ne hpq
exact natDegree_lt_natDegree hpq (degree_modByMonic_lt p hmq) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Div | {
"line": 177,
"column": 4
} | {
"line": 178,
"column": 65
} | {
"line": 180,
"column": 0
} | [
{
"pp": "case neg\nR : Type u\ninst✝ : Ring R\np q : R[X]\nhmq : q.Monic\nhq : q ≠ 1\nhpq : ¬p %ₘ q = 0\n⊢ (p %ₘ q).natDegree < q.natDegree",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Polynomial",
"Polynomial.Nontrivial.of_polynomial_ne",
"Polynomial.modByMonic",
... | [] | haveI := Nontrivial.of_polynomial_ne hpq
exact natDegree_lt_natDegree hpq (degree_modByMonic_lt p hmq) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Algebraic.Defs | {
"line": 104,
"column": 2
} | {
"line": 104,
"column": 75
} | {
"line": 106,
"column": 0
} | [
{
"pp": "R : Type u\nA : Type v\ninst✝² : CommRing R\ninst✝¹ : Ring A\ninst✝ : Algebra R A\n⊢ Algebra.IsAlgebraic R A ↔ ∀ x ∈ ⊤, IsAlgebraic R x",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Subalgebra.instSetLike",
"Lattice.toSemilatticeSup",
"IsAlgebraic",
"Com... | [] | simp only [Algebra.isAlgebraic_def, Algebra.mem_top, forall_prop_of_true] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Polynomial.Div | {
"line": 249,
"column": 12
} | {
"line": 249,
"column": 23
} | {
"line": 249,
"column": 24
} | [
{
"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))) %ₘ q =\n p ... | [
"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 (if hq : q.Monic then ((p - q * (C p.leadingCoeff * X ^ (p.natDegree - q.natDegree))).div... | modByMonic, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Div | {
"line": 381,
"column": 25
} | {
"line": 381,
"column": 46
} | {
"line": 381,
"column": 47
} | [
{
"pp": "R : Type u\nS : Type v\ninst✝¹ : Ring R\np q : R[X]\ninst✝ : Ring S\nf : R →+* S\nhq : q.Monic\na✝ : Nontrivial S\nthis : Nontrivial R\n⊢ map f p = map f (p %ₘ q) + map f q * map f (p /ₘ q)",
"ppTerm": "?m.110",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.map_mul"... | [
"R : Type u\nS : Type v\ninst✝¹ : Ring R\np q : R[X]\ninst✝ : Ring S\nf : R →+* S\nhq : q.Monic\na✝ : Nontrivial S\nthis : Nontrivial R\n⊢ map f p = map f (p %ₘ q) + map f (q * (p /ₘ q))"
] | ← Polynomial.map_mul, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Filter.Bases.Finite | {
"line": 59,
"column": 46
} | {
"line": 59,
"column": 77
} | {
"line": 61,
"column": 0
} | [
{
"pp": "α : Type u_1\ns : Set (Set α)\n⊢ (∀ {i : Set (Set α)}, i.Finite ∧ i ⊆ s → (⋂₀ i).Nonempty) ↔ ∀ t ⊆ s, t.Finite → (⋂₀ t).Nonempty",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"congrArg",
"Set.Finite",
"LE.le",
"iff_self",
"And",
"Iff",
"... | [] | simp only [← and_imp, and_comm] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Order.Filter.Bases.Finite | {
"line": 59,
"column": 46
} | {
"line": 59,
"column": 77
} | {
"line": 61,
"column": 0
} | [
{
"pp": "α : Type u_1\ns : Set (Set α)\n⊢ (∀ {i : Set (Set α)}, i.Finite ∧ i ⊆ s → (⋂₀ i).Nonempty) ↔ ∀ t ⊆ s, t.Finite → (⋂₀ t).Nonempty",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"congrArg",
"Set.Finite",
"LE.le",
"iff_self",
"And",
"Iff",
"... | [] | simp only [← and_imp, and_comm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Filter.Bases.Finite | {
"line": 59,
"column": 46
} | {
"line": 59,
"column": 77
} | {
"line": 61,
"column": 0
} | [
{
"pp": "α : Type u_1\ns : Set (Set α)\n⊢ (∀ {i : Set (Set α)}, i.Finite ∧ i ⊆ s → (⋂₀ i).Nonempty) ↔ ∀ t ⊆ s, t.Finite → (⋂₀ t).Nonempty",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"congrArg",
"Set.Finite",
"LE.le",
"iff_self",
"And",
"Iff",
"... | [] | simp only [← and_imp, and_comm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Filter.Ker | {
"line": 36,
"column": 52
} | {
"line": 36,
"column": 57
} | {
"line": 38,
"column": 0
} | [
{
"pp": "ι : Sort u_1\nα : Type u_2\nβ : Type u_3\nf g : Filter α\ns : Set α\na : α\n⊢ ∀ (b : Set α) (x : α), (∀ (s : Set α), (∀ x ∈ b, x ∈ s) → x ∈ s) → x ∈ b",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Membership.mem",
"True",
"eq_true",
"of_eq_true",
"... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Order.Filter.Finite | {
"line": 274,
"column": 2
} | {
"line": 274,
"column": 11
} | {
"line": 276,
"column": 0
} | [
{
"pp": "α : Type u\nι : Type u_2\nI : Set ι\nhI : I.Finite\nl : Filter α\np : ι → α → Prop\n⊢ (¬∃ᶠ (x : α) in l, ∃ i ∈ I, p i x) ↔ ¬∃ i ∈ I, ∃ᶠ (x : α) in l, p i x",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"not_exists._simp_1",
"congrArg",
"Filter.Eventually",
... | [] | simp [hI] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Order.Heyting.Boundary | {
"line": 92,
"column": 2
} | {
"line": 92,
"column": 67
} | {
"line": 93,
"column": 2
} | [
{
"pp": "α : Type u_1\ninst✝ : CoheytingAlgebra α\na✝ b✝ : α\na b : Prop\n⊢ (a ∧ b ∨ ¬(a ∧ b)) ∧ ((a ∨ b) ∨ ¬(a ∨ b)) → a ∨ ¬a",
"ppTerm": "?m.1",
"assigned": true,
"usedConstants": [
"Or.casesOn",
"And.casesOn",
"And",
"Or.inl",
"Or",
"Not"
],
"usedFVars"... | [
"case inr.inl.inr\nα : Type u_1\ninst✝ : CoheytingAlgebra α\na✝ b✝ : α\na b : Prop\nhnab : ¬(a ∧ b)\nhb : b\n⊢ a ∨ ¬a",
"case inr.inr\nα : Type u_1\ninst✝ : CoheytingAlgebra α\na✝ b✝ : α\na b : Prop\nhnab✝ : ¬(a ∧ b)\nhnab : ¬(a ∨ b)\n⊢ a ∨ ¬a"
] | rintro ⟨⟨ha, _⟩ | hnab, (ha | hb) | hnab⟩ <;> try exact Or.inl ha | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Order.Heyting.Boundary | {
"line": 126,
"column": 2
} | {
"line": 128,
"column": 30
} | {
"line": 130,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : CoheytingAlgebra α\na : α\n⊢ a \\ ∂ a = ￢￢a",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"CoheytingAlgebra.toHNot",
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Coheyting.hnot_boundary",
"congrArg",
"OrderBot.toBot",
"Pa... | [] | rw (occs := [1]) [← hnot_hnot_sup_boundary a]
rw [sup_sdiff_distrib, sdiff_self, sup_bot_eq, hnot_sdiff_comm,
hnot_boundary, top_sdiff'] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Heyting.Boundary | {
"line": 126,
"column": 2
} | {
"line": 128,
"column": 30
} | {
"line": 130,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : CoheytingAlgebra α\na : α\n⊢ a \\ ∂ a = ￢￢a",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"CoheytingAlgebra.toHNot",
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Coheyting.hnot_boundary",
"congrArg",
"OrderBot.toBot",
"Pa... | [] | rw (occs := [1]) [← hnot_hnot_sup_boundary a]
rw [sup_sdiff_distrib, sdiff_self, sup_bot_eq, hnot_sdiff_comm,
hnot_boundary, top_sdiff'] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Filter.Prod | {
"line": 55,
"column": 2
} | {
"line": 56,
"column": 64
} | {
"line": 57,
"column": 2
} | [
{
"pp": "case mp\nα : Type u_1\nβ : Type u_2\ns : Set (α × β)\nf : Filter α\ng : Filter β\n⊢ s ∈ f ×ˢ g → ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Filter.instMembership",
"Set.instSProd",
"SProd.sprod",
"Membership.mem",
... | [
"case mpr\nα : Type u_1\nβ : Type u_2\ns : Set (α × β)\nf : Filter α\ng : Filter β\n⊢ (∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s) → s ∈ f ×ˢ g"
] | · rintro ⟨t₁, ⟨s₁, hs₁, hts₁⟩, t₂, ⟨s₂, hs₂, hts₂⟩, rfl⟩
exact ⟨s₁, hs₁, s₂, hs₂, fun p ⟨h, h'⟩ => ⟨hts₁ h, hts₂ h'⟩⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.Filter.Prod | {
"line": 297,
"column": 23
} | {
"line": 297,
"column": 49
} | {
"line": 297,
"column": 49
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nf : Filter α\ng : Filter β\nh : Filter γ\n⊢ comap (fun x ↦ ((Equiv.prodAssoc α β γ).symm x).1.1) f ⊓\n (comap (fun x ↦ ((Equiv.prodAssoc α β γ).symm x).1.2) g ⊓ comap (fun x ↦ ((Equiv.prodAssoc α β γ).symm x).2) h) =\n comap Prod.fst f ⊓ (comap (fun x ↦... | [] | Equiv.prodAssoc_symm_apply | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Order.Filter.TendstoCofinite | {
"line": 120,
"column": 2
} | {
"line": 121,
"column": 59
} | {
"line": 122,
"column": 2
} | [
{
"pp": "case refine_1\nα : Type u_1\nβ : Type u_2\nf : α → β\ninst✝ : TendstoCofinite f\nx : β →₀ ℕ\ns : Finset α := x.support.sup fun t ↦ ⋯.toFinset\ne : ↥s ↪ α := Function.Embedding.subtype fun u ↦ u ∈ s\ny : α →₀ ℕ\nhy : mapDomain f y = x\n⊢ degree (comapDomain (⇑e) y ⋯) ≤ degree x",
"ppTerm": "?refine_... | [
"case refine_2\nα : Type u_1\nβ : Type u_2\nf : α → β\ninst✝ : TendstoCofinite f\nx : β →₀ ℕ\ns : Finset α := x.support.sup fun t ↦ ⋯.toFinset\ne : ↥s ↪ α := Function.Embedding.subtype fun u ↦ u ∈ s\ny : α →₀ ℕ\nhy : mapDomain f y = x\n⊢ ↑y.support ⊆ range ⇑e"
] | · rw [← hy, degree_mapDomain]
exact degree_comapDomain_le_of_canonicallyOrderedAdd .. | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Finsupp.Weight | {
"line": 307,
"column": 46
} | {
"line": 307,
"column": 51
} | {
"line": 308,
"column": 4
} | [
{
"pp": "σ : Type u_5\ng f : σ →₀ ℕ\nhgf : g ≤ g + f\nIH : degree g ≤ degree (g + f) → ∃ g_1 ≤ g + f, degree g_1 = degree g\nhn : degree g + 1 ≤ degree (g + f)\n⊢ f.support.Nonempty",
"ppTerm": "?m.91",
"assigned": true,
"usedConstants": [
"Finsupp.instAddZeroClass",
"Eq.mpr",
"Nat... | [] | aesop | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.