module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.NumberTheory.Divisors | {
"line": 684,
"column": 2
} | {
"line": 684,
"column": 35
} | {
"line": 686,
"column": 0
} | [
{
"pp": "z a✝ : ℤ\n⊢ a✝ ∈ image Prod.snd z.divisorsAntidiag ↔ a✝ ∈ z.divisors",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Int.divisors",
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Int.mem_divisorsAntidiag._simp_1",
"Semigroup.toMul",
"I... | [] | simp [Eq.comm, mul_comm, dvd_def] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.ZMod.Basic | {
"line": 1072,
"column": 4
} | {
"line": 1074,
"column": 35
} | {
"line": 1076,
"column": 0
} | [
{
"pp": "case succ\nn : ℕ\ninst✝ : Fact (1 < n)\na : ZMod n\nm : ℕ\nih : (a ^ m).val ≤ a.val ^ m\n⊢ (a ^ (m + 1)).val ≤ a.val ^ (m + 1)",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"ZMod.commRing",
"Monoid.toMulOneClass",
"congrArg",
... | [] | rw [pow_succ, pow_succ]
apply le_trans (ZMod.val_mul_le _ _)
apply Nat.mul_le_mul_right _ ih | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ZMod.Basic | {
"line": 1072,
"column": 4
} | {
"line": 1074,
"column": 35
} | {
"line": 1076,
"column": 0
} | [
{
"pp": "case succ\nn : ℕ\ninst✝ : Fact (1 < n)\na : ZMod n\nm : ℕ\nih : (a ^ m).val ≤ a.val ^ m\n⊢ (a ^ (m + 1)).val ≤ a.val ^ (m + 1)",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"ZMod.commRing",
"Monoid.toMulOneClass",
"congrArg",
... | [] | rw [pow_succ, pow_succ]
apply le_trans (ZMod.val_mul_le _ _)
apply Nat.mul_le_mul_right _ ih | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.ZMod.Basic | {
"line": 1119,
"column": 8
} | {
"line": 1119,
"column": 20
} | {
"line": 1119,
"column": 21
} | [
{
"pp": "case succ\nR : Type u_1\ninst✝ : NonAssocRing R\nn✝ : ℕ\nf : R →+* ZMod (n✝ + 1)\nk : ZMod (n✝ + 1)\n⊢ f ↑k.val = k",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomClass",
"ZMod.commRi... | [
"case succ\nR : Type u_1\ninst✝ : NonAssocRing R\nn✝ : ℕ\nf : R →+* ZMod (n✝ + 1)\nk : ZMod (n✝ + 1)\n⊢ ↑k.val = k"
] | map_natCast, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.ZMod.Basic | {
"line": 1266,
"column": 57
} | {
"line": 1266,
"column": 70
} | {
"line": 1266,
"column": 71
} | [
{
"pp": "α : Type u_1\ninst✝ : Group α\nn : ℕ\na : α\nhn : (Nat.card α).Coprime n\n⊢ a ^ (↑(n * (↑n)⁻¹.val)).val = a",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"ZMod.instInv",
"ZMod.commRin... | [
"α : Type u_1\ninst✝ : Group α\nn : ℕ\na : α\nhn : (Nat.card α).Coprime n\n⊢ a ^ (↑n * ↑(↑n)⁻¹.val).val = a"
] | Nat.cast_mul, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Digits.Defs | {
"line": 248,
"column": 6
} | {
"line": 252,
"column": 83
} | {
"line": 253,
"column": 4
} | [
{
"pp": "case succ.zero\nn : ℕ\n⊢ ofDigits (0 + 1) ((0 + 1).digits n) = n",
"ppTerm": "?succ.zero",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.recAux",
"congrArg",
"Nat.ofDigits",
"Nat.ofDigits_one_cons",
"... | [] | induction n with
| zero => rfl
| succ n ih =>
rw [Nat.zero_add] at ih ⊢
simp only [ih, add_comm 1, ofDigits_one_cons, Nat.cast_id, digits_one_succ] | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Nat.Digits.Defs | {
"line": 248,
"column": 6
} | {
"line": 252,
"column": 83
} | {
"line": 253,
"column": 4
} | [
{
"pp": "case succ.zero\nn : ℕ\n⊢ ofDigits (0 + 1) ((0 + 1).digits n) = n",
"ppTerm": "?succ.zero",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.recAux",
"congrArg",
"Nat.ofDigits",
"Nat.ofDigits_one_cons",
"... | [] | induction n with
| zero => rfl
| succ n ih =>
rw [Nat.zero_add] at ih ⊢
simp only [ih, add_comm 1, ofDigits_one_cons, Nat.cast_id, digits_one_succ] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Digits.Defs | {
"line": 248,
"column": 6
} | {
"line": 252,
"column": 83
} | {
"line": 253,
"column": 4
} | [
{
"pp": "case succ.zero\nn : ℕ\n⊢ ofDigits (0 + 1) ((0 + 1).digits n) = n",
"ppTerm": "?succ.zero",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.recAux",
"congrArg",
"Nat.ofDigits",
"Nat.ofDigits_one_cons",
"... | [] | induction n with
| zero => rfl
| succ n ih =>
rw [Nat.zero_add] at ih ⊢
simp only [ih, add_comm 1, ofDigits_one_cons, Nat.cast_id, digits_one_succ] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 56,
"column": 6
} | {
"line": 56,
"column": 38
} | {
"line": 56,
"column": 39
} | [
{
"pp": "case h\nb : ℕ\nhb : 1 < b\nn : ℕ\nIH : ∀ m < n, m ≠ 0 → (b.digits m).length = log b m + 1\nhn : n ≠ 0\n⊢ (b.digits n).length = log b n + 1",
"ppTerm": "?h",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"instHDiv",
"congrArg",
"id",
"HDiv.hDiv",
"Nat.ins... | [
"case h\nb : ℕ\nhb : 1 < b\nn : ℕ\nIH : ∀ m < n, m ≠ 0 → (b.digits m).length = log b m + 1\nhn : n ≠ 0\n⊢ (n % b :: b.digits (n / b)).length = log b n + 1"
] | digits_eq_cons_digits_div hb hn, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 100,
"column": 2
} | {
"line": 100,
"column": 62
} | {
"line": 101,
"column": 2
} | [
{
"pp": "b m n : ℕ\nhb : 0 < b\n⊢ b.digits n ++ b.digits m = b.digits (n + b ^ (b.digits n).length * m)",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"HMul.hMul",
"Nat.succ_le_of_lt",
"Nat.instMonoid",
"PartialOrder.toPreorder",
"instM... | [
"case inl\nm n : ℕ\nhb : 0 < succ 0\n⊢ (succ 0).digits n ++ (succ 0).digits m = (succ 0).digits (n + succ 0 ^ ((succ 0).digits n).length * m)",
"case inr\nb m n : ℕ\nhb✝ : 0 < b\nhb : succ 0 < b\n⊢ b.digits n ++ b.digits m = b.digits (n + b ^ (b.digits n).length * m)"
] | rcases eq_or_lt_of_le (Nat.succ_le_of_lt hb) with (rfl | hb) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.RingTheory.Multiplicity | {
"line": 203,
"column": 2
} | {
"line": 203,
"column": 50
} | {
"line": 205,
"column": 0
} | [
{
"pp": "case succ.isFalse\nα : Type u_1\ninst✝ : Monoid α\na b : α\nn✝ : ℕ\nh✝ : ¬FiniteMultiplicity a b\nhk : ↑(n✝ + 1) ≤ ⊤\n⊢ a ^ (n✝ + 1) ∣ b",
"ppTerm": "?succ.isFalse",
"assigned": true,
"usedConstants": [
"Dvd.dvd",
"semigroupDvd",
"instOfNatNat",
"NPow.toPow",
"... | [] | · apply FiniteMultiplicity.not_iff_forall.mp ‹_› | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 352,
"column": 4
} | {
"line": 352,
"column": 12
} | {
"line": 353,
"column": 4
} | [
{
"pp": "case pos\nn : ℕ\nhn : n = 0\n⊢ ∏ p ∈ n.primeFactors, p ∣ n",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Dvd.dvd",
"instOfNatNat",
"Finset.prod",
"Nat.instDvd",
"Nat",
"Nat.instCommMonoid",
"Eq.ndrec",
"Nat.primeFactors",
"O... | [
"case pos\n⊢ ∏ p ∈ primeFactors 0, p ∣ 0"
] | subst hn | Lean.Elab.Tactic.evalSubst | Lean.Parser.Tactic.subst |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 463,
"column": 6
} | {
"line": 463,
"column": 42
} | {
"line": 464,
"column": 4
} | [
{
"pp": "case pos\na b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\nh : ∀ (p : ℕ), Prime p → padicValNat p a = padicValNat p b\np : ℕ\npp : Prime p\n⊢ a.factorization p = b.factorization p",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Nat.instMulZeroClass",
"con... | [] | simp [factorization_def, pp, h p pp] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 463,
"column": 6
} | {
"line": 463,
"column": 42
} | {
"line": 464,
"column": 4
} | [
{
"pp": "case pos\na b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\nh : ∀ (p : ℕ), Prime p → padicValNat p a = padicValNat p b\np : ℕ\npp : Prime p\n⊢ a.factorization p = b.factorization p",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Nat.instMulZeroClass",
"con... | [] | simp [factorization_def, pp, h p pp] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 463,
"column": 6
} | {
"line": 463,
"column": 42
} | {
"line": 464,
"column": 4
} | [
{
"pp": "case pos\na b : ℕ\nha : a ≠ 0\nhb : b ≠ 0\nh : ∀ (p : ℕ), Prime p → padicValNat p a = padicValNat p b\np : ℕ\npp : Prime p\n⊢ a.factorization p = b.factorization p",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Nat.instMulZeroClass",
"con... | [] | simp [factorization_def, pp, h p pp] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 468,
"column": 2
} | {
"line": 468,
"column": 48
} | {
"line": 469,
"column": 2
} | [
{
"pp": "n : ℕ\nhn : n ≠ 0\nm : ℕ\npr : n < m\n⊢ ∏ p ∈ Finset.range m with Prime p, p ^ padicValNat p n = n",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instMulZeroClass",
"Nat.Prime",
"congrArg",
"Nat.instMonoid",
"id",
"padicVal... | [
"n : ℕ\nhn : n ≠ 0\nm : ℕ\npr : n < m\n⊢ ∏ p ∈ Finset.range m with Prime p, p ^ padicValNat p n = n.factorization.prod fun x1 x2 ↦ x1 ^ x2"
] | nth_rw 2 [← prod_factorization_pow_eq_self hn] | Mathlib.Tactic._aux_Mathlib_Tactic_NthRewrite___macroRules_Mathlib_Tactic_tacticNth_rw______1 | Mathlib.Tactic.tacticNth_rw_____ |
Mathlib.Data.Nat.Choose.Factorization | {
"line": 148,
"column": 4
} | {
"line": 153,
"column": 27
} | {
"line": 155,
"column": 0
} | [
{
"pp": "p n k : ℕ\nhkn : k + 1 ≤ n + 1\nhk : k + 1 ≠ 0\n⊢ (n + 1).factorization p ≤ ((n + 1).choose (k + 1)).factorization p + (k + 1).factorization p",
"ppTerm": "?m.55",
"assigned": true,
"usedConstants": [
"zero_le",
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instCanonicallyOr... | [] | rw [← Pi.add_apply, ← coe_add, ← factorization_mul (ne_of_gt <| choose_pos hkn)
(zero_ne_add_one k).symm]
refine factorization_le_factorization_of_dvd_right ?_ (zero_ne_add_one n).symm
(Nat.mul_ne_zero (ne_of_gt <| choose_pos hkn) (by positivity))
rw [← add_one_mul_choose_eq]
exact dvd_mul_right... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Choose.Factorization | {
"line": 148,
"column": 4
} | {
"line": 153,
"column": 27
} | {
"line": 155,
"column": 0
} | [
{
"pp": "p n k : ℕ\nhkn : k + 1 ≤ n + 1\nhk : k + 1 ≠ 0\n⊢ (n + 1).factorization p ≤ ((n + 1).choose (k + 1)).factorization p + (k + 1).factorization p",
"ppTerm": "?m.55",
"assigned": true,
"usedConstants": [
"zero_le",
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instCanonicallyOr... | [] | rw [← Pi.add_apply, ← coe_add, ← factorization_mul (ne_of_gt <| choose_pos hkn)
(zero_ne_add_one k).symm]
refine factorization_le_factorization_of_dvd_right ?_ (zero_ne_add_one n).symm
(Nat.mul_ne_zero (ne_of_gt <| choose_pos hkn) (by positivity))
rw [← add_one_mul_choose_eq]
exact dvd_mul_right... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.CharP.Lemmas | {
"line": 59,
"column": 96
} | {
"line": 60,
"column": 42
} | {
"line": 62,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\np : ℕ\nhp : Nat.Prime p\nx y : R\nh : Commute x y\n⊢ (x + y) ^ p = x ^ p + y ^ p + ↑p * ∑ k ∈ Ioo 0 p, x ^ k * y ^ (p - k) * ↑(p.choose k / p)",
"ppTerm": "?m.70",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"... | [] | by
simpa using h.add_pow_prime_pow_eq' hp 1 | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.OrderOfElement | {
"line": 685,
"column": 10
} | {
"line": 685,
"column": 73
} | {
"line": 686,
"column": 2
} | [
{
"pp": "G : Type u_1\ninst✝ : RightCancelMonoid G\nx : G\nm✝ n m k : ℕ\nhmn : m ≤ m + k\nh : x ^ (m + k) = x ^ m\nhk : x ^ k = 1\n⊢ m + k ≡ m [MOD orderOf x]",
"ppTerm": "?m.166",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Dvd.dvd",
"Monoid.toMulOneClass... | [] | by simpa using Nat.ModEq.add_left m (pow_eq_one_iff_modEq.1 hk) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.OrderOfElement | {
"line": 930,
"column": 4
} | {
"line": 930,
"column": 70
} | {
"line": 931,
"column": 4
} | [
{
"pp": "case inr\nG : Type u_1\ninst✝¹ : CommGroup G\ninst✝ : IsMulTorsionFree G\ng : G\nha : g ≠ 1\n⊢ orderOf g ≤ 1",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"InvOneClass.toOne",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOne... | [
"case inr\nG : Type u_1\ninst✝¹ : CommGroup G\ninst✝ : IsMulTorsionFree G\ng : G\nha : orderOf g = 0\n⊢ orderOf g ≤ 1"
] | rw [ne_eq, ← isOfFinOrder_iff_eq_one, ← orderOf_eq_zero_iff] at ha | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.OrderOfElement | {
"line": 942,
"column": 2
} | {
"line": 942,
"column": 47
} | {
"line": 943,
"column": 2
} | [
{
"pp": "G : Type u_1\ninst✝² : Monoid G\nn : ℕ\ninst✝¹ : Fintype G\ninst✝ : DecidableEq G\nhn : n ≠ 0\n⊢ ∑ m ∈ n.divisors, #{x | orderOf x = m} = #{x | x ^ n = 1}",
"ppTerm": "?m.30",
"assigned": true,
"usedConstants": [
"MulOne.toOne",
"Finset.univ",
"Monoid.toMulOneClass",
... | [
"case refine_1\nG : Type u_1\ninst✝² : Monoid G\nn : ℕ\ninst✝¹ : Fintype G\ninst✝ : DecidableEq G\nhn : n ≠ 0\n⊢ (↑n.divisors).PairwiseDisjoint fun m ↦ {x | orderOf x = m}",
"case refine_2\nG : Type u_1\ninst✝² : Monoid G\nn : ℕ\ninst✝¹ : Fintype G\ninst✝ : DecidableEq G\nhn : n ≠ 0\n⊢ #(n.divisors.biUnion fun m ... | refine (Finset.card_biUnion ?_).symm.trans ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Nat.Multiplicity | {
"line": 278,
"column": 6
} | {
"line": 278,
"column": 14
} | {
"line": 279,
"column": 6
} | [
{
"pp": "case pos\nh2 : _root_.Prime 2\nb : Bool\nn : ℕ\nih : n ≠ 0 → emultiplicity 2 n ! < ↑n\nh : bit b n ≠ 0\nhn : n = 0\n⊢ emultiplicity 2 (bit b n)! < ↑(bit b n)",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Nat.bit",
"ENat.instNatCast",
"Nat.instMonoid",
"N... | [
"case pos\nh2 : _root_.Prime 2\nb : Bool\nih : 0 ≠ 0 → emultiplicity 2 0! < ↑0\nh : bit b 0 ≠ 0\n⊢ emultiplicity 2 (bit b 0)! < ↑(bit b 0)"
] | subst hn | Lean.Elab.Tactic.evalSubst | Lean.Parser.Tactic.subst |
Mathlib.GroupTheory.OrderOfElement | {
"line": 1440,
"column": 47
} | {
"line": 1440,
"column": 60
} | {
"line": 1440,
"column": 61
} | [
{
"pp": "case mp\nR : Type u_6\ninst✝¹ : NonAssocRing R\np : ℕ\ninst✝ : Fintype R\nhn : card R = p\nhR : ∀ i < p, ↑i = 0 → i = 0\nn : ℕ\nH : ↑p = 0\nh : ↑(n % p) + ↑(p * (n / p)) = 0\n⊢ p ∣ n",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
... | [
"case mp\nR : Type u_6\ninst✝¹ : NonAssocRing R\np : ℕ\ninst✝ : Fintype R\nhn : card R = p\nhR : ∀ i < p, ↑i = 0 → i = 0\nn : ℕ\nH : ↑p = 0\nh : ↑(n % p) + ↑p * ↑(n / p) = 0\n⊢ p ∣ n"
] | Nat.cast_mul, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.OrderOfElement | {
"line": 1446,
"column": 10
} | {
"line": 1446,
"column": 23
} | {
"line": 1446,
"column": 24
} | [
{
"pp": "case mpr\nR : Type u_6\ninst✝¹ : NonAssocRing R\np : ℕ\ninst✝ : Fintype R\nhn : card R = p\nhR : ∀ i < p, ↑i = 0 → i = 0\nH : ↑p = 0\nn : ℕ\n⊢ ↑(p * n) = 0",
"ppTerm": "?mpr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.h... | [
"case mpr\nR : Type u_6\ninst✝¹ : NonAssocRing R\np : ℕ\ninst✝ : Fintype R\nhn : card R = p\nhR : ∀ i < p, ↑i = 0 → i = 0\nH : ↑p = 0\nn : ℕ\n⊢ ↑p * ↑n = 0"
] | Nat.cast_mul, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.RingDivision | {
"line": 180,
"column": 2
} | {
"line": 180,
"column": 37
} | {
"line": 181,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\na b c : R\nha : IsUnit a\n⊢ rootMultiplicity c (p.comp (C a * X + C b)) ≤ rootMultiplicity (a * c + b) p",
"ppTerm": "?m.38",
"assigned": true,
"usedConstants": [
"CommSemiring.toSemiring",
"AddGroupWithOne.toAddMonoidWithOne",
"in... | [
"R : Type u\ninst✝ : CommRing R\np : R[X]\na b c : R\nha : IsUnit a\nthis : Invertible a := ha.invertible\n⊢ rootMultiplicity c (p.comp (C a * X + C b)) ≤ rootMultiplicity (a * c + b) p"
] | let : Invertible a := ha.invertible | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Algebra.Polynomial.RingDivision | {
"line": 190,
"column": 2
} | {
"line": 190,
"column": 37
} | {
"line": 191,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\na b c : R\nha : IsUnit a\n⊢ rootMultiplicity c (p.comp (C a * X + C b)) = rootMultiplicity (a * c + b) p",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"CommSemiring.toSemiring",
"AddGroupWithOne.toAddMonoidWithOne",
"in... | [
"R : Type u\ninst✝ : CommRing R\np : R[X]\na b c : R\nha : IsUnit a\nthis : Invertible a := ha.invertible\n⊢ rootMultiplicity c (p.comp (C a * X + C b)) = rootMultiplicity (a * c + b) p"
] | let : Invertible a := ha.invertible | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Algebra.Polynomial.RingDivision | {
"line": 189,
"column": 84
} | {
"line": 194,
"column": 64
} | {
"line": 196,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\na b c : R\nha : IsUnit a\n⊢ rootMultiplicity c (p.comp (C a * X + C b)) = rootMultiplicity (a * c + b) p",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"Polynomial.C",
"Polynom... | [] | by
let : Invertible a := ha.invertible
apply le_antisymm (rootMultiplicity_comp_C_mul_X_add_C_le p a b c ha)
have := rootMultiplicity_comp_C_mul_X_add_C_le
(p.comp (C a * X + C b)) ⅟a (- ⅟a * b) (a * c + b) (isUnit_of_invertible ⅟a)
simpa [comp_assoc, mul_add, ← mul_assoc, ← map_mul] using this | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.RingDivision | {
"line": 256,
"column": 23
} | {
"line": 256,
"column": 49
} | {
"line": 256,
"column": 49
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\np : R[X]\nhc : IsRelPrime (p.coeff 0) (p.coeff 1)\nf g : R[X]\nhp : f.degree + g.degree = 1\nh : p = f * g\nH : f.degree ≤ g.degree\n⊢ IsUnit f",
"ppTerm": "?m.142",
"assigned": true,
"usedConstants": [
"WithBot.instPreorder",
... | [
"R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\np : R[X]\nhc : IsRelPrime (p.coeff 0) (p.coeff 1)\nf g : R[X]\nhp : f.degree = 0 ∧ g.degree = 1 ∨ f.degree = 1 ∧ g.degree = 0\nh : p = f * g\nH : f.degree ≤ g.degree\n⊢ IsUnit f"
] | Nat.WithBot.add_eq_one_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Div | {
"line": 55,
"column": 6
} | {
"line": 55,
"column": 11
} | {
"line": 56,
"column": 6
} | [
{
"pp": "case succ\nR : Type u\ninst✝ : Semiring R\nf : R[X]\nn : ℕ\nhn : (∀ d < n, f.coeff d = 0) → X ^ n ∣ f\nhd : ∀ d < n + 1, f.coeff d = 0\ng : R[X]\nhgf : f = X ^ n * g\nthis : 0 = g.coeff 0\nk : R[X]\nhgk : g = X * k\n⊢ X ^ (n + 1) ∣ f",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [... | [
"case h\nR : Type u\ninst✝ : Semiring R\nf : R[X]\nn : ℕ\nhn : (∀ d < n, f.coeff d = 0) → X ^ n ∣ f\nhd : ∀ d < n + 1, f.coeff d = 0\ng : R[X]\nhgf : f = X ^ n * g\nthis : 0 = g.coeff 0\nk : R[X]\nhgk : g = X * k\n⊢ f = X ^ (n + 1) * k"
] | use k | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.Algebra.Polynomial.RingDivision | {
"line": 325,
"column": 12
} | {
"line": 325,
"column": 58
} | {
"line": 325,
"column": 58
} | [
{
"pp": "R : Type u\ninst✝² : CommRing R\ninst✝¹ : IsDomain R\ninst✝ : DecidableEq R\np : R[X]\nhp : p ≠ 0\nthis : Decidable (∃ x, p.IsRoot x)\nh : ∃ x, p.IsRoot x\nx : R\nhx : p.IsRoot x\nhpd : 0 < p.degree\nhd0 : p /ₘ (X - C x) ≠ 0\nwf : (p /ₘ (X - C x)).degree < p.degree\nt : Multiset R\nhtd : ↑t.card ≤ (p /... | [] | exact add_le_add (le_refl (1 : WithBot ℕ)) htd | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Polynomial.Expand | {
"line": 120,
"column": 15
} | {
"line": 120,
"column": 68
} | {
"line": 122,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nn : ℕ\nhn : 0 < n\ng g' : R[X]\nH : (expand R n) g = (expand R n) g'\nk : ℕ\n⊢ g.coeff k = g'.coeff k",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"Al... | [] | by rw [← coeff_expand_mul hn, H, coeff_expand_mul hn] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Div | {
"line": 277,
"column": 4
} | {
"line": 278,
"column": 89
} | {
"line": 278,
"column": 89
} | [
{
"pp": "R : Type u\ninst✝¹ : Ring R\np q : R[X]\ninst✝ : Nontrivial R\nhq : q.Monic\nh : p.degree < q.degree\n⊢ p /ₘ q = 0",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"WithBot.instPreorder",
"Eq.mpr",
"Polynomial.C",
"instDecidableNot",
"WithBot",
"... | [] | have : ¬degree q ≤ degree p := not_le_of_gt h
unfold divByMonic divModByMonicAux; dsimp; rw [dif_pos hq, if_neg (mt And.left this)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Div | {
"line": 277,
"column": 4
} | {
"line": 278,
"column": 89
} | {
"line": 278,
"column": 89
} | [
{
"pp": "R : Type u\ninst✝¹ : Ring R\np q : R[X]\ninst✝ : Nontrivial R\nhq : q.Monic\nh : p.degree < q.degree\n⊢ p /ₘ q = 0",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"WithBot.instPreorder",
"Eq.mpr",
"Polynomial.C",
"instDecidableNot",
"WithBot",
"... | [] | have : ¬degree q ≤ degree p := not_le_of_gt h
unfold divByMonic divModByMonicAux; dsimp; rw [dif_pos hq, if_neg (mt And.left this)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Expand | {
"line": 312,
"column": 76
} | {
"line": 316,
"column": 76
} | {
"line": 318,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\np : ℕ\nhp : 0 < p\n⊢ IsLocalHom (expand R p)",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"dvd_zero",
"IsDomain.to_noZeroDivisors",
"Dvd.dvd",
"instHDiv",
"P... | [] | by
refine ⟨fun f hf1 => ?_⟩
have hf2 := eq_C_of_degree_eq_zero (degree_eq_zero_of_isUnit hf1)
rw [coeff_expand hp, if_pos (dvd_zero _), p.zero_div] at hf2
rw [hf2, isUnit_C] at hf1; rw [expand_eq_C hp] at hf2; rwa [hf2, isUnit_C] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Filter.Pi | {
"line": 104,
"column": 70
} | {
"line": 105,
"column": 91
} | {
"line": 107,
"column": 0
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\nf : (i : ι) → Filter (α i)\nι' : ι → Type u_3\ns : (i : ι) → ι' i → Set (α i)\np : (i : ι) → ι' i → Prop\nh : ∀ (i : ι), (f i).HasBasis (p i) (s i)\n⊢ (pi f).HasBasis (fun If ↦ If.1.Finite ∧ ∀ i ∈ If.1, p i (If.2 i)) fun If ↦ If.1.pi fun i ↦ s i (If.2 i)",
"ppTerm": ... | [] | by
simpa [Set.pi_def] using! HasBasis.iInf' fun i => (h i).comap (eval i : (∀ j, α j) → α i) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Filter.Finite | {
"line": 193,
"column": 2
} | {
"line": 203,
"column": 61
} | {
"line": 205,
"column": 0
} | [
{
"pp": "α : Type u\nβ : Type v\ns : Finset α\nf : α → Filter β\nt : Set β\n⊢ t ∈ ⨅ a ∈ s, f a ↔ ∃ p, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ a ∈ s, p a",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
"Filter.instMembership",
"dite_cond_eq_true",
"Iff.mpr",
"Eq.mpr",
"iI... | [] | classical
simp only [← Finset.set_biInter_coe, biInter_eq_iInter, iInf_subtype']
refine ⟨fun h => ?_, ?_⟩
· rcases (mem_iInf_of_finite _).1 h with ⟨p, hp, rfl⟩
refine ⟨fun a => if h : a ∈ s then p ⟨a, h⟩ else univ,
fun a ha => by simpa [ha] using hp ⟨a, ha⟩, ?_⟩
refine iInter_congr_of_surjecti... | Lean.Elab.Tactic.evalClassical | Lean.Parser.Tactic.classical |
Mathlib.Order.Filter.Finite | {
"line": 193,
"column": 2
} | {
"line": 203,
"column": 61
} | {
"line": 205,
"column": 0
} | [
{
"pp": "α : Type u\nβ : Type v\ns : Finset α\nf : α → Filter β\nt : Set β\n⊢ t ∈ ⨅ a ∈ s, f a ↔ ∃ p, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ a ∈ s, p a",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
"Filter.instMembership",
"dite_cond_eq_true",
"Iff.mpr",
"Eq.mpr",
"iI... | [] | classical
simp only [← Finset.set_biInter_coe, biInter_eq_iInter, iInf_subtype']
refine ⟨fun h => ?_, ?_⟩
· rcases (mem_iInf_of_finite _).1 h with ⟨p, hp, rfl⟩
refine ⟨fun a => if h : a ∈ s then p ⟨a, h⟩ else univ,
fun a ha => by simpa [ha] using hp ⟨a, ha⟩, ?_⟩
refine iInter_congr_of_surjecti... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Filter.Finite | {
"line": 193,
"column": 2
} | {
"line": 203,
"column": 61
} | {
"line": 205,
"column": 0
} | [
{
"pp": "α : Type u\nβ : Type v\ns : Finset α\nf : α → Filter β\nt : Set β\n⊢ t ∈ ⨅ a ∈ s, f a ↔ ∃ p, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ a ∈ s, p a",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
"Filter.instMembership",
"dite_cond_eq_true",
"Iff.mpr",
"Eq.mpr",
"iI... | [] | classical
simp only [← Finset.set_biInter_coe, biInter_eq_iInter, iInf_subtype']
refine ⟨fun h => ?_, ?_⟩
· rcases (mem_iInf_of_finite _).1 h with ⟨p, hp, rfl⟩
refine ⟨fun a => if h : a ∈ s then p ⟨a, h⟩ else univ,
fun a ha => by simpa [ha] using hp ⟨a, ha⟩, ?_⟩
refine iInter_congr_of_surjecti... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Div | {
"line": 704,
"column": 2
} | {
"line": 706,
"column": 47
} | {
"line": 708,
"column": 0
} | [
{
"pp": "case neg.h₁\nR : Type u\ninst✝ : CommRing R\np₁ p₂ q : R[X]\nh : q.Monic\nthis : p₁ * p₂ - p₁ %ₘ q * (p₂ %ₘ q) = p₁ %ₘ q * (p₂ - p₂ %ₘ q) + p₂ * (p₁ - p₁ %ₘ q)\n⊢ q ∣ p₁ %ₘ q * (p₂ - p₂ %ₘ q)",
"ppTerm": "?neg.h₁✝",
"assigned": true,
"usedConstants": [
"Dvd.dvd",
"HMul.hMul",
... | [] | all_goals
· apply dvd_mul_of_dvd_right
simp [Polynomial.modByMonic_eq_sub_mul_div] | Lean.Elab.Tactic.evalAllGoals | Lean.Parser.Tactic.allGoals |
Mathlib.Algebra.Polynomial.Div | {
"line": 762,
"column": 8
} | {
"line": 762,
"column": 34
} | {
"line": 762,
"column": 35
} | [
{
"pp": "case neg.refine_1\nR : Type u\ninst✝ : CommRing R\np : R[X]\nh : ¬p = 0\n⊢ rootMultiplicity 0 p ≤ p.natTrailingDegree",
"ppTerm": "?neg.refine_1✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Dvd.dvd",
"CommRing.toNonUnitalCommRing",
"congrA... | [
"case neg.refine_1\nR : Type u\ninst✝ : CommRing R\np : R[X]\nh : ¬p = 0\n⊢ ¬(X - C 0) ^ (p.natTrailingDegree + 1) ∣ p"
] | rootMultiplicity_le_iff h, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 577,
"column": 2
} | {
"line": 577,
"column": 62
} | {
"line": 578,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nn : ℕ\np : R[X]\n⊢ (⇑derivative)^[n] ((⇑derivative)^[2] p * X ^ 2) =\n (⇑derivative)^[n + 2] p * X ^ 2 + (2 * n) • (⇑derivative)^[n + 1] p * X + (n * (n - 1)) • (⇑derivative)^[n] p",
"ppTerm": "?m.115",
"assigned": true,
"usedConstants": [
"Polyn... | [
"R : Type u\ninst✝ : CommSemiring R\nn : ℕ\np : R[X]\n⊢ (⇑derivative)^[n + 2] p * X ^ 2 + (2 * n) • (⇑derivative)^[n + 1] p * X + (n * (n - 1)) • (⇑derivative)^[n] p =\n ∑ k ∈ range (min 2 n).succ,\n (n.choose k * Nat.descFactorial 2 k) • ((⇑derivative)^[n - k] ((⇑derivative)^[2] p) * X ^ (2 - k))"
] | convert! (derivative^[2] p).iterate_derivative_mul_X_pow n 2 | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___macroRules_Mathlib_Tactic_convert!_1 | Mathlib.Tactic.convert! |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 609,
"column": 23
} | {
"line": 609,
"column": 48
} | {
"line": 609,
"column": 49
} | [
{
"pp": "R : Type u\nι : Type y\ninst✝¹ : CommSemiring R\ninst✝ : DecidableEq ι\ns✝ : Multiset ι\nf : ι → R[X]\ni : ι\ns : Multiset ι\nh :\n derivative (Multiset.map f s).prod =\n (Multiset.map (fun i ↦ (Multiset.map f (s.erase i)).prod * derivative (f i)) s).sum\n⊢ derivative (f i) * (Multiset.map f s).pro... | [
"R : Type u\nι : Type y\ninst✝¹ : CommSemiring R\ninst✝ : DecidableEq ι\ns✝ : Multiset ι\nf : ι → R[X]\ni : ι\ns : Multiset ι\nh :\n derivative (Multiset.map f s).prod =\n (Multiset.map (fun i ↦ (Multiset.map f (s.erase i)).prod * derivative (f i)) s).sum\n⊢ derivative (f i) * (Multiset.map f s).prod + f i * de... | Multiset.erase_cons_head, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 712,
"column": 22
} | {
"line": 712,
"column": 32
} | {
"line": 713,
"column": 6
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\nk : ℕ\nind : ∀ {P : R[X]}, P.degree < ↑k → (⇑derivative)^[k] P = 0\nP : R[X]\nh : P.degree < ↑(k + 1)\nhP : ¬P = 0\nhP' : derivative P = 0\n⊢ (⇑derivative)^[k] (derivative P) = 0",
"ppTerm": "?m.79",
"assigned": true,
"usedConstants": [
"Polynomial.deri... | [] | simp [hP'] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 712,
"column": 22
} | {
"line": 712,
"column": 32
} | {
"line": 713,
"column": 6
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\nk : ℕ\nind : ∀ {P : R[X]}, P.degree < ↑k → (⇑derivative)^[k] P = 0\nP : R[X]\nh : P.degree < ↑(k + 1)\nhP : ¬P = 0\nhP' : derivative P = 0\n⊢ (⇑derivative)^[k] (derivative P) = 0",
"ppTerm": "?m.79",
"assigned": true,
"usedConstants": [
"Polynomial.deri... | [] | simp [hP'] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 712,
"column": 22
} | {
"line": 712,
"column": 32
} | {
"line": 713,
"column": 6
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\nk : ℕ\nind : ∀ {P : R[X]}, P.degree < ↑k → (⇑derivative)^[k] P = 0\nP : R[X]\nh : P.degree < ↑(k + 1)\nhP : ¬P = 0\nhP' : derivative P = 0\n⊢ (⇑derivative)^[k] (derivative P) = 0",
"ppTerm": "?m.79",
"assigned": true,
"usedConstants": [
"Polynomial.deri... | [] | simp [hP'] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Filter.Cofinite | {
"line": 324,
"column": 2
} | {
"line": 325,
"column": 39
} | {
"line": 326,
"column": 2
} | [
{
"pp": "case refine_3\nα : Type u_2\nf : Filter α\n⊢ f = 𝓟 (f.ker, Coheyting.boundary f).1 ⊔ (f.ker, Coheyting.boundary f).2",
"ppTerm": "?refine_3",
"assigned": true,
"usedConstants": [
"CoheytingAlgebra.toHNot",
"Eq.mpr",
"Lattice.toSemilatticeSup",
"compl_compl",
"... | [
"case refine_4\nα : Type u_2\nf : Filter α\nq : Set α × Filter α\nhq : (fun p ↦ p.2 ≤ cofinite ∧ Disjoint (𝓟 p.1) p.2 ∧ f = 𝓟 p.1 ⊔ p.2) q\n⊢ q = (f.ker, Coheyting.boundary f)"
] | · rw [← compl_compl f.ker, ← hnot_principal, ← Filter.hnot_def,
Coheyting.hnot_hnot_sup_boundary] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.Filter.TendstoCofinite | {
"line": 122,
"column": 30
} | {
"line": 122,
"column": 39
} | {
"line": 123,
"column": 4
} | [
{
"pp": "α : 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\nthis : y.support ⊆ s\n⊢ ↑y.support ⊆ range ⇑e",
"ppTerm": "?m.109",
"assign... | [] | simpa [e] | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Order.Filter.TendstoCofinite | {
"line": 122,
"column": 30
} | {
"line": 122,
"column": 39
} | {
"line": 123,
"column": 4
} | [
{
"pp": "α : 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\nthis : y.support ⊆ s\n⊢ ↑y.support ⊆ range ⇑e",
"ppTerm": "?m.109",
"assign... | [] | simpa [e] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Filter.TendstoCofinite | {
"line": 122,
"column": 30
} | {
"line": 122,
"column": 39
} | {
"line": 123,
"column": 4
} | [
{
"pp": "α : 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\nthis : y.support ⊆ s\n⊢ ↑y.support ⊆ range ⇑e",
"ppTerm": "?m.109",
"assign... | [] | simpa [e] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 730,
"column": 74
} | {
"line": 730,
"column": 87
} | {
"line": 730,
"column": 88
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\nS : Finset R\nk : ℕ\nind : (⇑derivative)^[k] (∏ a ∈ S, (X - C a)) = ↑k ! * ∑ T ∈ powersetCard (#S - k) S, ∏ a ∈ T, (X - C a)\nhk : k + 1 ≤ #S\n⊢ ↑k ! * ∑ b ∈ powersetCard (#S - k) S, derivative (∏ a ∈ b, (X - C a)) =\n ↑(k ! * (k + 1)) * ∑ T ∈ powersetCard (#S - (k + ... | [
"R : Type u\ninst✝ : CommRing R\nS : Finset R\nk : ℕ\nind : (⇑derivative)^[k] (∏ a ∈ S, (X - C a)) = ↑k ! * ∑ T ∈ powersetCard (#S - k) S, ∏ a ∈ T, (X - C a)\nhk : k + 1 ≤ #S\n⊢ ↑k ! * ∑ b ∈ powersetCard (#S - k) S, derivative (∏ a ∈ b, (X - C a)) =\n ↑k ! * ↑(k + 1) * ∑ T ∈ powersetCard (#S - (k + 1)) S, ∏ a ∈ ... | Nat.cast_mul, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Finsupp.Weight | {
"line": 188,
"column": 44
} | {
"line": 201,
"column": 10
} | {
"line": 203,
"column": 0
} | [
{
"pp": "σ : Type u_1\ninst✝ : Finite σ\nw : σ → ℕ\nhw : ∀ (x : σ), w x ≠ 0\nn : ℕ\n⊢ {d | (weight w) d ≤ n}.Finite",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"Finsupp.instHasAntidiagonal",
"Finsupp.instAddZeroClass",
"Finsupp.instFunLike",
"Eq.mpr",
"Nat... | [] | by
classical
set fg := Finset.antidiagonal (Finsupp.equivFunOnFinite.symm (Function.const σ n)) with hfg
suffices {d : σ →₀ ℕ | weight w d ≤ n} ⊆ ↑(fg.image fun uv => uv.fst) by
exact Set.Finite.subset (Finset.finite_toSet _) this
intro d hd
rw [hfg]
simp only [Finset.coe_image, Set.mem_image, Finset.me... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 132,
"column": 2
} | {
"line": 140,
"column": 46
} | {
"line": 142,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\n⊢ normalizedFactors 1 = 0",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"UniqueFactorizationMonoid.normalizedFactors",
"dite_cond_eq_true",
"Nontri... | [] | rcases subsingleton_or_nontrivial α with h | h
· dsimp [normalizedFactors, factors]
simp [Subsingleton.elim (1 : α) 0]
· rw [← Multiset.rel_zero_right]
apply factors_unique irreducible_of_normalized_factor
· intro x hx
exfalso
apply Multiset.notMem_zero x hx
· apply prod_normalizedFactor... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 132,
"column": 2
} | {
"line": 140,
"column": 46
} | {
"line": 142,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\n⊢ normalizedFactors 1 = 0",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"UniqueFactorizationMonoid.normalizedFactors",
"dite_cond_eq_true",
"Nontri... | [] | rcases subsingleton_or_nontrivial α with h | h
· dsimp [normalizedFactors, factors]
simp [Subsingleton.elim (1 : α) 0]
· rw [← Multiset.rel_zero_right]
apply factors_unique irreducible_of_normalized_factor
· intro x hx
exfalso
apply Multiset.notMem_zero x hx
· apply prod_normalizedFactor... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.UniqueFactorizationDomain.Basic | {
"line": 345,
"column": 10
} | {
"line": 345,
"column": 61
} | {
"line": 346,
"column": 10
} | [
{
"pp": "case neg.calc_1\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : IsCancelMulZero α\npf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a\na b : α\nane0 : a ≠ 0\nc : α\nhc : ¬IsUnit c\nb_eq : b = a * c\nh : ¬b = 0\ncne0 : c ≠ 0\ncon : Classical.choose ⋯ = 0\n⊢ c ~ᵤ 1",
"ppTerm": "?neg.... | [
"α : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : IsCancelMulZero α\npf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a\na b : α\nane0 : a ≠ 0\nc : α\nhc : ¬IsUnit c\nb_eq : b = a * c\nh : ¬b = 0\ncne0 : c ≠ 0\ncon : Classical.choose ⋯ = 0\n⊢ 1 = (Classical.choose ⋯).prod"
] | convert! (Classical.choose_spec (pf c cne0)).2.symm | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___macroRules_Mathlib_Tactic_convert!_1 | Mathlib.Tactic.convert! |
Mathlib.Algebra.Polynomial.Roots | {
"line": 428,
"column": 44
} | {
"line": 434,
"column": 26
} | {
"line": 436,
"column": 0
} | [
{
"pp": "R : Type u\nn : ℕ\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\nη₁ η₂ a₁ a₂ : R\nhη₁ : η₁ ∈ nthRootsFinset n a₁\nhη₂ : η₂ ∈ nthRootsFinset n a₂\n⊢ η₁ * η₂ ∈ nthRootsFinset n (a₁ * a₂)",
"ppTerm": "?m.30",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"HMul.hMul",
... | [] | by
cases n with
| zero =>
simp only [nthRootsFinset_zero, notMem_empty] at hη₁
| succ n =>
rw [mem_nthRootsFinset n.succ_pos] at hη₁ hη₂ ⊢
rw [mul_pow, hη₁, hη₂] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.FieldDivision | {
"line": 89,
"column": 32
} | {
"line": 96,
"column": 62
} | {
"line": 98,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\nt : R\nn : ℕ\nh : p ≠ 0\nhroot : ∀ m ≤ n, ((⇑derivative)^[m] p).IsRoot t\nhnzd : ↑n ! ∈ nonZeroDivisors R\n⊢ n < rootMultiplicity t p",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Polynomial.derivative",
"Polynomial.C",
... | [] | by
by_contra! h'
replace hroot := hroot _ h'
simp only [IsRoot, eval_iterate_derivative_rootMultiplicity] at hroot
obtain ⟨q, hq⟩ : ((rootMultiplicity t p)! : R) ∣ n ! := by gcongr
rw [hq, mul_mem_nonZeroDivisors] at hnzd
rw [nsmul_eq_mul, mul_left_mem_nonZeroDivisors_eq_zero_iff hnzd.1] at hroot
exact ev... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.FieldDivision | {
"line": 110,
"column": 28
} | {
"line": 110,
"column": 41
} | {
"line": 110,
"column": 42
} | [
{
"pp": "case succ\nR : Type u\ninst✝ : CommRing R\np : R[X]\nt : R\nh : p ≠ 0\nn : ℕ\nih : (∀ m ≤ n, m ≠ 0 → ↑m ∈ nonZeroDivisors R) → ↑n ! ∈ nonZeroDivisors R\nhnzd : ∀ m ≤ n + 1, m ≠ 0 → ↑m ∈ nonZeroDivisors R\n⊢ ↑((n + 1) * n !) ∈ nonZeroDivisors R",
"ppTerm": "?succ",
"assigned": true,
"usedCon... | [
"case succ\nR : Type u\ninst✝ : CommRing R\np : R[X]\nt : R\nh : p ≠ 0\nn : ℕ\nih : (∀ m ≤ n, m ≠ 0 → ↑m ∈ nonZeroDivisors R) → ↑n ! ∈ nonZeroDivisors R\nhnzd : ∀ m ≤ n + 1, m ≠ 0 → ↑m ∈ nonZeroDivisors R\n⊢ ↑(n + 1) * ↑n ! ∈ nonZeroDivisors R"
] | Nat.cast_mul, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Roots | {
"line": 522,
"column": 6
} | {
"line": 522,
"column": 13
} | {
"line": 522,
"column": 14
} | [
{
"pp": "S : Type v\nT : Type w\ninst✝³ : CommRing T\ninst✝² : CommRing S\ninst✝¹ : IsDomain S\ninst✝ : Algebra T S\np : T[X]\n⊢ (-p).aroots S = p.aroots S",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.roots",
"Polynomial.instNeg",
"Algebra.a... | [
"S : Type v\nT : Type w\ninst✝³ : CommRing T\ninst✝² : CommRing S\ninst✝¹ : IsDomain S\ninst✝ : Algebra T S\np : T[X]\n⊢ (map (algebraMap T S) (-p)).roots = p.aroots S"
] | aroots, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Polynomial.Content | {
"line": 203,
"column": 2
} | {
"line": 210,
"column": 13
} | {
"line": 212,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝¹ : CommRing R\ninst✝ : NormalizedGCDMonoid R\np : R[X]\nr : R\n⊢ r ∣ p.content ↔ C r ∣ p",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Dvd.dvd",
"CommRing.toNonUnitalCommRing",
"congrArg",
"CommSe... | [] | rw [C_dvd_iff_dvd_coeff]
constructor
· intro h i
apply h.trans (content_dvd_coeff _)
· intro h
rw [content, Finset.dvd_gcd_iff]
intro i _
apply h i | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Polynomial.Content | {
"line": 203,
"column": 2
} | {
"line": 210,
"column": 13
} | {
"line": 212,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝¹ : CommRing R\ninst✝ : NormalizedGCDMonoid R\np : R[X]\nr : R\n⊢ r ∣ p.content ↔ C r ∣ p",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Dvd.dvd",
"CommRing.toNonUnitalCommRing",
"congrArg",
"CommSe... | [] | rw [C_dvd_iff_dvd_coeff]
constructor
· intro h i
apply h.trans (content_dvd_coeff _)
· intro h
rw [content, Finset.dvd_gcd_iff]
intro i _
apply h i | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.UniqueFactorizationDomain.Basic | {
"line": 457,
"column": 6
} | {
"line": 461,
"column": 27
} | {
"line": 462,
"column": 4
} | [
{
"pp": "case pos\nR : Type u_2\ninst✝¹ : CommMonoidWithZero R\ninst✝ : UniqueFactorizationMonoid R\na✝ a p : R\na_ne_zero : a ≠ 0\np_prime : Prime p\nih_a : a ≠ 0 → ∀ (b : R), ∃ a' b' c', IsRelPrime a' b' ∧ c' * a' = a ∧ c' * b' = b\npa_ne_zero : p * a ≠ 0\nb : R\nh : p ∣ b\n⊢ ∃ a' b' c', IsRelPrime a' b' ∧ c'... | [] | rcases h with ⟨b, rfl⟩
obtain ⟨a', b', c', no_factor, ha', hb'⟩ := ih_a a_ne_zero b
refine ⟨a', b', p * c', @no_factor, ?_, ?_⟩
· rw [mul_assoc, ha']
· rw [mul_assoc, hb'] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.UniqueFactorizationDomain.Basic | {
"line": 457,
"column": 6
} | {
"line": 461,
"column": 27
} | {
"line": 462,
"column": 4
} | [
{
"pp": "case pos\nR : Type u_2\ninst✝¹ : CommMonoidWithZero R\ninst✝ : UniqueFactorizationMonoid R\na✝ a p : R\na_ne_zero : a ≠ 0\np_prime : Prime p\nih_a : a ≠ 0 → ∀ (b : R), ∃ a' b' c', IsRelPrime a' b' ∧ c' * a' = a ∧ c' * b' = b\npa_ne_zero : p * a ≠ 0\nb : R\nh : p ∣ b\n⊢ ∃ a' b' c', IsRelPrime a' b' ∧ c'... | [] | rcases h with ⟨b, rfl⟩
obtain ⟨a', b', c', no_factor, ha', hb'⟩ := ih_a a_ne_zero b
refine ⟨a', b', p * c', @no_factor, ?_, ?_⟩
· rw [mul_assoc, ha']
· rw [mul_assoc, hb'] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.UniqueFactorizationDomain.Basic | {
"line": 466,
"column": 8
} | {
"line": 466,
"column": 77
} | {
"line": 467,
"column": 8
} | [
{
"pp": "case neg.inl\nR : Type u_2\ninst✝¹ : CommMonoidWithZero R\ninst✝ : UniqueFactorizationMonoid R\na p : R\np_prime : Prime p\na' b' c' : R\ncoprime : IsRelPrime a' b'\na_ne_zero : c' * a' ≠ 0\nih_a : c' * a' ≠ 0 → ∀ (b : R), ∃ a'_1 b' c'_1, IsRelPrime a'_1 b' ∧ c'_1 * a'_1 = c' * a' ∧ c'_1 * b' = b\npa_n... | [
"case neg.inl\nR : Type u_2\ninst✝¹ : CommMonoidWithZero R\ninst✝ : UniqueFactorizationMonoid R\na p : R\np_prime : Prime p\na' b' c' : R\ncoprime : IsRelPrime a' b'\na_ne_zero : c' * a' ≠ 0\nih_a : c' * a' ≠ 0 → ∀ (b : R), ∃ a'_1 b' c'_1, IsRelPrime a'_1 b' ∧ c'_1 * a'_1 = c' * a' ∧ c'_1 * b' = b\npa_ne_zero : p *... | have : p ∣ c' * b' := dvd_mul_of_dvd_right (p_dvd_q.trans q_dvd_b') _ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {
"line": 392,
"column": 2
} | {
"line": 410,
"column": 12
} | {
"line": 412,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\na b : α\nha : a ≠ 0\nhb : b ≠ 0\nh : Associates.mk a ⊓ Associates.mk b ≠ 1\n⊢ ∃ p, Prime p ∧ p ∣ a ∧ p ∣ b",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Multiset.prod_zero",
"CommMonoi... | [] | classical
have hz : factors (Associates.mk a) ⊓ factors (Associates.mk b) ≠ 0 := by
contrapose h with hf
change (factors (Associates.mk a) ⊓ factors (Associates.mk b)).prod = 1
rw [hf]
exact Multiset.prod_zero
rw [factors_mk a ha, factors_mk b hb, ← WithTop.coe_inf] at hz
obtain ⟨⟨p0, p0_irr⟩, p0_... | Lean.Elab.Tactic.evalClassical | Lean.Parser.Tactic.classical |
Mathlib.Algebra.Polynomial.FieldDivision | {
"line": 711,
"column": 39
} | {
"line": 711,
"column": 69
} | {
"line": 711,
"column": 69
} | [
{
"pp": "case neg\nR : Type u\ninst✝¹ : Field R\np q : R[X]\ninst✝ : DecidableEq R\nhq : q ≠ 0\nhp : ¬p = 0\n⊢ Irreducible p ∧ normalize p = p ∧ p ∣ q ↔ Irreducible p ∧ p.Monic ∧ p ∣ q",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Polynomial.instNormalizationMonoid",
"Eq.mpr... | [
"case neg\nR : Type u\ninst✝¹ : Field R\np q : R[X]\ninst✝ : DecidableEq R\nhq : q ≠ 0\nhp : ¬p = 0\n⊢ Irreducible p ∧ p.Monic ∧ p ∣ q ↔ Irreducible p ∧ p.Monic ∧ p ∣ q"
] | normalize_eq_self_iff_monic hp | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {
"line": 392,
"column": 2
} | {
"line": 410,
"column": 12
} | {
"line": 412,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\na b : α\nha : a ≠ 0\nhb : b ≠ 0\nh : Associates.mk a ⊓ Associates.mk b ≠ 1\n⊢ ∃ p, Prime p ∧ p ∣ a ∧ p ∣ b",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Multiset.prod_zero",
"CommMonoi... | [] | classical
have hz : factors (Associates.mk a) ⊓ factors (Associates.mk b) ≠ 0 := by
contrapose h with hf
change (factors (Associates.mk a) ⊓ factors (Associates.mk b)).prod = 1
rw [hf]
exact Multiset.prod_zero
rw [factors_mk a ha, factors_mk b hb, ← WithTop.coe_inf] at hz
obtain ⟨⟨p0, p0_irr⟩, p0_... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {
"line": 392,
"column": 2
} | {
"line": 410,
"column": 12
} | {
"line": 412,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\na b : α\nha : a ≠ 0\nhb : b ≠ 0\nh : Associates.mk a ⊓ Associates.mk b ≠ 1\n⊢ ∃ p, Prime p ∧ p ∣ a ∧ p ∣ b",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Multiset.prod_zero",
"CommMonoi... | [] | classical
have hz : factors (Associates.mk a) ⊓ factors (Associates.mk b) ≠ 0 := by
contrapose h with hf
change (factors (Associates.mk a) ⊓ factors (Associates.mk b)).prod = 1
rw [hf]
exact Multiset.prod_zero
rw [factors_mk a ha, factors_mk b hb, ← WithTop.coe_inf] at hz
obtain ⟨⟨p0, p0_irr⟩, p0_... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Polynomial.UniqueFactorization | {
"line": 93,
"column": 2
} | {
"line": 93,
"column": 53
} | {
"line": 94,
"column": 2
} | [
{
"pp": "σ : Type v\nD : Type u\ninst✝¹ : CommRing D\ninst✝ : UniqueFactorizationMonoid D\n⊢ UniqueFactorizationMonoid D[X]",
"ppTerm": "?m.4",
"assigned": true,
"usedConstants": [
"NormalizedGCDMonoid",
"CommSemiring.toCommMonoidWithZero",
"instNonemptyNormalizedGCDMonoidOfIsGCDMo... | [
"σ : Type v\nD : Type u\ninst✝¹ : CommRing D\ninst✝ : UniqueFactorizationMonoid D\nthis : NormalizedGCDMonoid D := Classical.arbitrary (NormalizedGCDMonoid D)\n⊢ UniqueFactorizationMonoid D[X]"
] | letI := Classical.arbitrary (NormalizedGCDMonoid D) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLetI___1 | Lean.Parser.Tactic.tacticLetI__ |
Mathlib.RingTheory.Polynomial.UniqueFactorization | {
"line": 107,
"column": 2
} | {
"line": 107,
"column": 74
} | {
"line": 108,
"column": 2
} | [
{
"pp": "σ : Type v\nD : Type u\ninst✝¹ : CommRing D\ninst✝ : UniqueFactorizationMonoid D\nf : D[X]\nhf : f ≠ 0\nG : Type u := { g // g.Monic ∧ g ∣ f }\ny : Associates D[X] := Associates.mk f\nhy : y ≠ 0\nH : Type (max 0 u) := { x // x ∣ y }\n⊢ Fintype G",
"ppTerm": "?m.50",
"assigned": true,
"usedC... | [
"σ : Type v\nD : Type u\ninst✝¹ : CommRing D\ninst✝ : UniqueFactorizationMonoid D\nf : D[X]\nhf : f ≠ 0\nG : Type u := { g // g.Monic ∧ g ∣ f }\ny : Associates D[X] := Associates.mk f\nhy : y ≠ 0\nH : Type (max 0 u) := { x // x ∣ y }\nhfin : Fintype H := fintypeSubtypeDvd y hy\n⊢ Fintype G"
] | let hfin : Fintype H := UniqueFactorizationMonoid.fintypeSubtypeDvd y hy | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.RingTheory.Algebraic.Basic | {
"line": 682,
"column": 2
} | {
"line": 682,
"column": 37
} | {
"line": 683,
"column": 2
} | [
{
"pp": "K : Type u_1\nL : Type u_2\ninst✝² : Field K\ninst✝¹ : Field L\ninst✝ : Algebra K L\nA : Subalgebra K L\nx : ↥A\nhx : IsAlgebraic K ↑x\n⊢ (↑x)⁻¹ ∈ A",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Subalgebra.instSetLike",
"DivisionCommMonoid.toDivisionMonoid",
"... | [
"K : Type u_1\nL : Type u_2\ninst✝² : Field K\ninst✝¹ : Field L\ninst✝ : Algebra K L\nA : Subalgebra K L\nx : ↥A\np : K[X]\nne_zero : p ≠ 0\naeval_eq : (aeval ↑x) p = 0\n⊢ (↑x)⁻¹ ∈ A"
] | obtain ⟨p, ne_zero, aeval_eq⟩ := hx | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Order.DirectedInverseSystem | {
"line": 177,
"column": 30
} | {
"line": 177,
"column": 45
} | {
"line": 177,
"column": 46
} | [
{
"pp": "ι : Type u_1\ninst✝⁷ : Preorder ι\nF₁ : ι → Type u_2\nF₂ : ι → Type u_3\nF : ι → Type u_4\nX : ι → Type u_5\nT₁ : ⦃i j : ι⦄ → i ≤ j → Sort u_6\nf₁ : (i j : ι) → (h : i ≤ j) → T₁ h\ninst✝⁶ : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T₁ h) (F₁ i) (F₁ j)\ninst✝⁵ : DirectedSystem F₁ fun x1 x2 x3 ↦ ⇑(f₁ x1 x2 x3)\... | [
"ι : Type u_1\ninst✝⁷ : Preorder ι\nF₁ : ι → Type u_2\nF₂ : ι → Type u_3\nF : ι → Type u_4\nX : ι → Type u_5\nT₁ : ⦃i j : ι⦄ → i ≤ j → Sort u_6\nf₁ : (i j : ι) → (h : i ≤ j) → T₁ h\ninst✝⁶ : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T₁ h) (F₁ i) (F₁ j)\ninst✝⁵ : DirectedSystem F₁ fun x1 x2 x3 ↦ ⇑(f₁ x1 x2 x3)\nT₂ : ⦃i j :... | compat _ _ hxk, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Colimit.Finiteness | {
"line": 59,
"column": 7
} | {
"line": 59,
"column": 19
} | {
"line": 61,
"column": 0
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝³ : Semiring R\ninst✝² : AddCommMonoid M\ninst✝¹ : Module R M\ninst✝ : DecidableEq (Submodule R M)\nN : { N // N.FG }\nx✝ : ↥↑N\n⊢ (↑(equiv R M) ∘ₗ of R { N // N.FG } (fun i ↦ ↥↑i) (fgSystem R M) N) x✝ = (↑N).subtype x✝",
"ppTerm": "?m.87",
"assigned": true,
... | [] | simp [equiv] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Colimit.Module | {
"line": 405,
"column": 50
} | {
"line": 407,
"column": 32
} | {
"line": 407,
"column": 33
} | [
{
"pp": "R : Type u_1\ninst✝⁶ : Semiring R\nι : Type u_2\ninst✝⁵ : Preorder ι\nG : ι → Type u_3\ninst✝⁴ : (i : ι) → AddCommMonoid (G i)\nf : (i j : ι) → i ≤ j → G i →+ G j\ninst✝³ : DecidableEq ι\nP : Type u_4\ninst✝² : AddCommMonoid P\ng : (i : ι) → G i →+ P\nHg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f... | [] | by
rw [AddMonoidHom.comp_assoc, hg₁ i, ← AddMonoidHom.comp_assoc, hg₂ i,
AddMonoidHom.comp_assoc] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Flat.Basic | {
"line": 103,
"column": 39
} | {
"line": 103,
"column": 63
} | {
"line": 103,
"column": 64
} | [
{
"pp": "R : Type u\nM : Type v\nN : Type u_1\nP : Type u_2\nQ : Type u_3\ninst✝⁸ : CommSemiring R\ninst✝⁷ : AddCommMonoid M\ninst✝⁶ : Module R M\ninst✝⁵ : AddCommMonoid N\ninst✝⁴ : Module R N\ninst✝³ : AddCommMonoid P\ninst✝² : Module R P\ninst✝¹ : AddCommMonoid Q\ninst✝ : Module R Q\nf : N →ₗ[R] P\nhf : Injec... | [
"R : Type u\nM : Type v\nN : Type u_1\nP : Type u_2\nQ : Type u_3\ninst✝⁸ : CommSemiring R\ninst✝⁷ : AddCommMonoid M\ninst✝⁶ : Module R M\ninst✝⁵ : AddCommMonoid N\ninst✝⁴ : Module R N\ninst✝³ : AddCommMonoid P\ninst✝² : Module R P\ninst✝¹ : AddCommMonoid Q\ninst✝ : Module R Q\nf : N →ₗ[R] P\nhf : Injective ⇑f\ne :... | LinearEquiv.coe_rTensor, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Colimit.DirectLimit | {
"line": 236,
"column": 26
} | {
"line": 236,
"column": 72
} | {
"line": 238,
"column": 0
} | [
{
"pp": "ι : Type u_2\ninst✝⁹ : Preorder ι\nG : ι → Type u_3\nH : ι → Type u_4\nC : Type u_5\nT : ⦃i j : ι⦄ → i ≤ j → Type u_6\nf : (x x_1 : ι) → (h : x ≤ x_1) → T h\ninst✝⁸ : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)\ninst✝⁷ : (i : ι) → FunLike (H i) (G i) C\ninst✝⁶ : DirectedSystem G fun x1 x2 x3 ↦ ... | [] | by simp_rw [npow_def, lift_def, map_pow (g i)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Flat.Basic | {
"line": 252,
"column": 4
} | {
"line": 252,
"column": 38
} | {
"line": 252,
"column": 38
} | [
{
"pp": "R : Type u\nM : Type v\ninst✝⁵ : CommSemiring R\ninst✝⁴ : AddCommMonoid M\ninst✝³ : Module R M\nS : Type u_4\ninst✝² : Semiring S\ninst✝¹ : Algebra R S\ninst✝ : Flat R S\nι : Type u_5\nv : ι → M\nhv : LinearIndependent R v\n⊢ Injective ⇑(↑R (Finsupp.linearCombination S fun x ↦ 1 ⊗ₜ[R] v x))",
"ppTe... | [
"R : Type u\nM : Type v\ninst✝⁵ : CommSemiring R\ninst✝⁴ : AddCommMonoid M\ninst✝³ : Module R M\nS : Type u_4\ninst✝² : Semiring S\ninst✝¹ : Algebra R S\ninst✝ : Flat R S\nι : Type u_5\nv : ι → M\nhv : LinearIndependent R v\n⊢ Injective ⇑(lTensor S (Finsupp.linearCombination R v) ∘ₗ ↑(finsuppScalarRight R R S ι).sy... | Finsupp.linearCombination_one_tmul | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Colimit.DirectLimit | {
"line": 265,
"column": 52
} | {
"line": 266,
"column": 88
} | {
"line": 267,
"column": 2
} | [
{
"pp": "R : Type u_1\nι : Type u_2\ninst✝⁹ : Preorder ι\nG : ι → Type u_3\nH : ι → Type u_4\nC : Type u_5\nT : ⦃i j : ι⦄ → i ≤ j → Type u_6\nf : (x x_1 : ι) → (h : x ≤ x_1) → T h\ninst✝⁸ : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)\ninst✝⁷ : (i : ι) → FunLike (H i) (G i) C\ninst✝⁶ : DirectedSystem G f... | [] | by
simp_rw [HPow.hPow, Pow.pow, map_def, mul_def]; congr; apply DivInvMonoid.zpow_succ' | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Colimit.DirectLimit | {
"line": 351,
"column": 52
} | {
"line": 352,
"column": 88
} | {
"line": 353,
"column": 2
} | [
{
"pp": "R : Type u_1\nι : Type u_2\ninst✝⁹ : Preorder ι\nG : ι → Type u_3\nH : ι → Type u_4\nC : Type u_5\nT : ⦃i j : ι⦄ → i ≤ j → Type u_6\nf : (x x_1 : ι) → (h : x ≤ x_1) → T h\ninst✝⁸ : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)\ninst✝⁷ : (i : ι) → FunLike (H i) (G i) C\ninst✝⁶ : DirectedSystem G f... | [] | by
simp_rw [HPow.hPow, Pow.pow, map_def, mul_def]; congr; apply DivInvMonoid.zpow_succ' | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.BigOperators.Expect | {
"line": 176,
"column": 4
} | {
"line": 176,
"column": 22
} | {
"line": 177,
"column": 2
} | [
{
"pp": "case inl\nι : Type u_1\nM : Type u_4\ninst✝² : AddCommMonoid M\ninst✝¹ : Module ℚ≥0 M\ninst✝ : DecidableEq ι\ns t : Finset ι\nf : ι → M\nhst : s ∩ t = ∅\n⊢ (𝔼 i ∈ s, if i ∈ t then f i else 0) = (↑(#(s ∩ t)) / ↑(#s)) • 𝔼 i ∈ s ∩ t, f i",
"ppTerm": "?inl",
"assigned": true,
"usedConstants":... | [] | simp [expect, hst] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.BigOperators.Expect | {
"line": 176,
"column": 4
} | {
"line": 176,
"column": 22
} | {
"line": 177,
"column": 2
} | [
{
"pp": "case inl\nι : Type u_1\nM : Type u_4\ninst✝² : AddCommMonoid M\ninst✝¹ : Module ℚ≥0 M\ninst✝ : DecidableEq ι\ns t : Finset ι\nf : ι → M\nhst : s ∩ t = ∅\n⊢ (𝔼 i ∈ s, if i ∈ t then f i else 0) = (↑(#(s ∩ t)) / ↑(#s)) • 𝔼 i ∈ s ∩ t, f i",
"ppTerm": "?inl",
"assigned": true,
"usedConstants":... | [] | simp [expect, hst] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Expect | {
"line": 176,
"column": 4
} | {
"line": 176,
"column": 22
} | {
"line": 177,
"column": 2
} | [
{
"pp": "case inl\nι : Type u_1\nM : Type u_4\ninst✝² : AddCommMonoid M\ninst✝¹ : Module ℚ≥0 M\ninst✝ : DecidableEq ι\ns t : Finset ι\nf : ι → M\nhst : s ∩ t = ∅\n⊢ (𝔼 i ∈ s, if i ∈ t then f i else 0) = (↑(#(s ∩ t)) / ↑(#s)) • 𝔼 i ∈ s ∩ t, f i",
"ppTerm": "?inl",
"assigned": true,
"usedConstants":... | [] | simp [expect, hst] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Density | {
"line": 71,
"column": 91
} | {
"line": 72,
"column": 13
} | {
"line": 74,
"column": 0
} | [
{
"pp": "α : Type u_2\ninst✝ : Fintype α\na : α\n⊢ {a}.dens = (↑(Fintype.card α))⁻¹",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"DivInvMonoid.toInv",
"NNRat.instInv",
"instHDiv",
"GroupWithZero.toDivInvMonoid",
... | [] | by
simp [dens] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.Density | {
"line": 137,
"column": 93
} | {
"line": 138,
"column": 13
} | {
"line": 140,
"column": 0
} | [
{
"pp": "𝕜 : Type u_1\nα : Type u_2\ninst✝² : Fintype α\ninst✝¹ : Semifield 𝕜\ninst✝ : CharZero 𝕜\ns : Finset α\n⊢ ↑s.dens = ↑(#s) / ↑(Fintype.card α)",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHDiv",
"GroupWithZero.... | [] | by
simp [dens] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.BigOperators.Ring.Nat | {
"line": 52,
"column": 60
} | {
"line": 52,
"column": 89
} | {
"line": 52,
"column": 89
} | [
{
"pp": "ι : Type u_1\nM : Type u_2\nf : ι → M\ns : Finset M\nhb : ∀ b ∈ s, {a | f a = b}.Finite\nt : Finset M := ⋯.toFinset\nht : (f ⁻¹' ↑t).Finite\nm : M\nhm : m ∈ t\nthis : {a | f a = m} ⊆ ↑ht.toFinset\na : ι\n⊢ a ∈ {a ∈ ht.toFinset | f a = m} ↔ a ∈ ⋯.toFinset",
"ppTerm": "?m.142",
"assigned": true,
... | [] | by simpa using fun h ↦ this h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.IsTensorProduct | {
"line": 189,
"column": 4
} | {
"line": 189,
"column": 29
} | {
"line": 190,
"column": 2
} | [
{
"pp": "R✝ : Type u_1\ninst✝³⁵ : CommSemiring R✝\nM₁✝ : Type u_2\nM₂✝ : Type u_3\nM : Type u_4\nM' : Type u_5\ninst✝³⁴ : AddCommMonoid M₁✝\ninst✝³³ : AddCommMonoid M₂✝\ninst✝³² : AddCommMonoid M\ninst✝³¹ : AddCommMonoid M'\ninst✝³⁰ : Module R✝ M₁✝\ninst✝²⁹ : Module R✝ M₂✝\ninst✝²⁸ : Module R✝ M\ninst✝²⁷ : Modu... | [] | apply hf.equiv_symm_apply | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.List.Sym | {
"line": 258,
"column": 13
} | {
"line": 260,
"column": 14
} | {
"line": 261,
"column": 2
} | [
{
"pp": "α : Type u_1\nn : ℕ\nxs✝ : List α\na : α\nxs : List α\nz : Sym α 0\nha : a ∈ z\nhz : z ∈ List.sym 0 xs\n⊢ a ∈ xs",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"False",
"Sym.nil",
"HEq.refl",
"False.elim",
"Sym.notMem_nil._simp_1",
"Membership.... | [] | by
cases Sym.eq_nil_of_card_zero z
simp at ha | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.IsTensorProduct | {
"line": 735,
"column": 4
} | {
"line": 738,
"column": 35
} | {
"line": 739,
"column": 2
} | [
{
"pp": "case refine_3\nR : Type u_1\nS : Type v₃\ninst✝¹² : CommSemiring R\ninst✝¹¹ : CommSemiring S\ninst✝¹⁰ : Algebra R S\nR' : Type u_6\nS' : Type u_7\ninst✝⁹ : CommSemiring R'\ninst✝⁸ : CommSemiring S'\ninst✝⁷ : Algebra R R'\ninst✝⁶ : Algebra S S'\ninst✝⁵ : Algebra R' S'\ninst✝⁴ : Algebra R S'\ninst✝³ : Is... | [] | intro s s' e
rw [Algebra.smul_def, map_mul, map_mul, e]
congr 1
exact (AlgHom.congr_fun h₂ s :) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.IsTensorProduct | {
"line": 735,
"column": 4
} | {
"line": 738,
"column": 35
} | {
"line": 739,
"column": 2
} | [
{
"pp": "case refine_3\nR : Type u_1\nS : Type v₃\ninst✝¹² : CommSemiring R\ninst✝¹¹ : CommSemiring S\ninst✝¹⁰ : Algebra R S\nR' : Type u_6\nS' : Type u_7\ninst✝⁹ : CommSemiring R'\ninst✝⁸ : CommSemiring S'\ninst✝⁷ : Algebra R R'\ninst✝⁶ : Algebra S S'\ninst✝⁵ : Algebra R' S'\ninst✝⁴ : Algebra R S'\ninst✝³ : Is... | [] | intro s s' e
rw [Algebra.smul_def, map_mul, map_mul, e]
congr 1
exact (AlgHom.congr_fun h₂ s :) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Quiver.Symmetric | {
"line": 228,
"column": 29
} | {
"line": 228,
"column": 65
} | {
"line": 230,
"column": 0
} | [
{
"pp": "U : Type u_1\nV : Type u_2\nW : Type u_3\ninst✝² : Quiver U\ninst✝¹ : Quiver V\ninst✝ : Quiver W\nV' : Type u_4\nσ : V → V'\nh : HasInvolutiveReverse V\na✝ b✝ : Push σ\nX✝ Y✝ : V\nf : X✝ ⟶ Y✝\n⊢ reverse (reverse (PushQuiver.arrow f)) = PushQuiver.arrow f",
"ppTerm": "?m.145",
"assigned": true,
... | [] | dsimp [reverse]; congr; apply h.inv' | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.Quiver.Symmetric | {
"line": 228,
"column": 29
} | {
"line": 228,
"column": 65
} | {
"line": 230,
"column": 0
} | [
{
"pp": "U : Type u_1\nV : Type u_2\nW : Type u_3\ninst✝² : Quiver U\ninst✝¹ : Quiver V\ninst✝ : Quiver W\nV' : Type u_4\nσ : V → V'\nh : HasInvolutiveReverse V\na✝ b✝ : Push σ\nX✝ Y✝ : V\nf : X✝ ⟶ Y✝\n⊢ reverse (reverse (PushQuiver.arrow f)) = PushQuiver.arrow f",
"ppTerm": "?m.145",
"assigned": true,
... | [] | dsimp [reverse]; congr; apply h.inv' | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Quiver.Path | {
"line": 338,
"column": 38
} | {
"line": 338,
"column": 54
} | {
"line": 338,
"column": 54
} | [
{
"pp": "V : Type u₁\ninst✝¹ : Quiver V\nW : Type u₂\ninst✝ : Quiver W\nF : V ⥤q W\na b : V\np : Path a b\nc b✝ : V\nq : Path b b✝\ne : b✝ ⟶ c\n⊢ (F.mapPath (p.comp q)).cons (F.map e) = ((F.mapPath p).comp (F.mapPath q)).cons (F.map e)",
"ppTerm": "?m.119",
"assigned": true,
"usedConstants": [
... | [
"V : Type u₁\ninst✝¹ : Quiver V\nW : Type u₂\ninst✝ : Quiver W\nF : V ⥤q W\na b : V\np : Path a b\nc b✝ : V\nq : Path b b✝\ne : b✝ ⟶ c\n⊢ ((F.mapPath p).comp (F.mapPath q)).cons (F.map e) = ((F.mapPath p).comp (F.mapPath q)).cons (F.map e)"
] | mapPath_comp p q | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.EqToHom | {
"line": 70,
"column": 68
} | {
"line": 71,
"column": 14
} | {
"line": 73,
"column": 0
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nX Y : C\nh : X = Y\n⊢ eqToHom h ≍ 𝟙 X",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.eqToHom",
"CategoryTheory.CategoryStruct.id",
"Eq.... | [] | by
subst h; rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.EqToHom | {
"line": 75,
"column": 68
} | {
"line": 76,
"column": 14
} | {
"line": 78,
"column": 0
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nX Y : C\nh : X = Y\n⊢ eqToHom h ≍ 𝟙 Y",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.eqToHom",
"CategoryTheory.CategoryStruct.id",
"Eq.... | [] | by
subst h; rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Opposites | {
"line": 659,
"column": 51
} | {
"line": 659,
"column": 67
} | {
"line": 659,
"column": 67
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nF G : C ⥤ D\nα : F ≅ G\nx✝ : Cᵒᵖ\n⊢ (α.inv.app (unop x✝) ≫ α.hom.app (unop x✝)).op = 𝟙 (op (G.obj (unop x✝)))",
"ppTerm": "?m.68",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"CategoryTheory... | [
"C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nF G : C ⥤ D\nα : F ≅ G\nx✝ : Cᵒᵖ\n⊢ (𝟙 (G.obj (unop x✝))).op = 𝟙 (op (G.obj (unop x✝)))"
] | α.inv_hom_id_app | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Pi.Basic | {
"line": 256,
"column": 4
} | {
"line": 257,
"column": 28
} | {
"line": 259,
"column": 0
} | [
{
"pp": "I : Type w₀\nJ : Type w₁\nC : I → Type u₁\ninst✝² : (i : I) → Category.{v₁, u₁} (C i)\nD : I → Type u₂\ninst✝¹ : (i : I) → Category.{v₂, u₂} (D i)\nF✝ G✝ : (i : I) → C i ⥤ D i\nE : Type u_1\ninst✝ : Category.{v_1, u_1} E\nF G : E ⥤ ((i : I) → C i)\nτ : (i : I) → F ⋙ Pi.eval C i ⟶ G ⋙ Pi.eval C i\nx✝¹ x... | [] | ext i
exact (τ i).naturality f | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Pi.Basic | {
"line": 256,
"column": 4
} | {
"line": 257,
"column": 28
} | {
"line": 259,
"column": 0
} | [
{
"pp": "I : Type w₀\nJ : Type w₁\nC : I → Type u₁\ninst✝² : (i : I) → Category.{v₁, u₁} (C i)\nD : I → Type u₂\ninst✝¹ : (i : I) → Category.{v₂, u₂} (D i)\nF✝ G✝ : (i : I) → C i ⥤ D i\nE : Type u_1\ninst✝ : Category.{v_1, u_1} E\nF G : E ⥤ ((i : I) → C i)\nτ : (i : I) → F ⋙ Pi.eval C i ⟶ G ⋙ Pi.eval C i\nx✝¹ x... | [] | ext i
exact (τ i).naturality f | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Equivalence | {
"line": 680,
"column": 96
} | {
"line": 681,
"column": 83
} | {
"line": 683,
"column": 0
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nF : C ⥤ D\ninst✝ : F.IsEquivalence\nX Y : D\nf : X ⟶ Y\n⊢ F.map (F.inv.map f) = F.asEquivalence.counit.app X ≫ f ≫ F.asEquivalence.counitInv.app Y",
"ppTerm": "?m.67",
"assigned": true,
"usedConstants": [
... | [] | by
simpa using! (NatIso.naturality_2 (α := F.asEquivalence.counitIso) (f := f)).symm | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.CommSq | {
"line": 276,
"column": 2
} | {
"line": 276,
"column": 87
} | {
"line": 278,
"column": 0
} | [
{
"pp": "C : Type u_1\ninst✝ : Category.{v_1, u_1} C\nA B X Y : Cᵒᵖ\nf : A ⟶ X\ni : A ⟶ B\np : X ⟶ Y\ng : B ⟶ Y\nsq : CommSq f i p g\n⊢ Nonempty sq.LiftStruct ↔ Nonempty ⋯.LiftStruct",
"ppTerm": "?m.83",
"assigned": true,
"usedConstants": [
"CategoryTheory.CommSq.LiftStruct.unopEquiv",
"... | [] | exact Nonempty.congr (LiftStruct.unopEquiv sq).toFun (LiftStruct.unopEquiv sq).invFun | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.MorphismProperty.Basic | {
"line": 348,
"column": 79
} | {
"line": 350,
"column": 19
} | {
"line": 352,
"column": 0
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nα : Type u_3\nι : α → Type u_4\nA B : (a : α) → ι a → C\nf : (a : α) → (i : ι a) → A a i ⟶ B a i\n⊢ ⨆ a, ofHoms (f a) = ofHoms fun j ↦ f j.fst j.snd",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"CategoryTheory.MorphismProperty",
... | [] | by
ext f
simp [ofHoms_iff] | [anonymous] | Lean.Parser.Term.byTactic |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.