module stringlengths 16 90 | startPos dict | endPos dict | nextStartPos dict | goals listlengths 0 96 | goalsAfter listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 371
values | kind stringclasses 375
values |
|---|---|---|---|---|---|---|---|---|
Mathlib.Data.Nat.Factors | {
"line": 253,
"column": 4
} | {
"line": 263,
"column": 29
} | {
"line": 265,
"column": 0
} | [
{
"pp": "case succ\na : ℕ\nha : Prime a\nn : ℕ\nih : ∀ {b : ℕ}, b ≠ 0 → (replicate n a <+~ b.primeFactorsList ↔ a ^ n ∣ b)\nb : ℕ\nhb : b ≠ 0\n⊢ replicate (n + 1) a <+~ b.primeFactorsList ↔ a ^ (n + 1) ∣ b",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"Nat.pow_succ'",
"instPo... | [] | constructor
· rw [List.subperm_iff]
rintro ⟨u, hu1, hu2⟩
rw [← Nat.prod_primeFactorsList hb, ← hu1.prod_eq, ← prod_replicate]
exact hu2.prod_dvd_prod
· rintro ⟨c, rfl⟩
rw [Ne, pow_succ', mul_assoc, mul_eq_zero, _root_.not_or] at hb
rw [pow_succ', mul_assoc, replicate_succ,
... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Index | {
"line": 231,
"column": 2
} | {
"line": 231,
"column": 70
} | {
"line": 232,
"column": 2
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH K : Subgroup G\n⊢ H.relIndex K = 2 ↔ ∃ a ∈ K, a ∉ H ∧ ∀ b ∈ K, a * b ∈ H ∨ b ∈ H",
"ppTerm": "?m.31",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Subgroup.subgroupOf",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"... | [
"G : Type u_1\ninst✝ : Group G\nH K : Subgroup G\n⊢ (∃ a ∉ H.subgroupOf K, ∀ (b : ↥K), a * b ∈ H.subgroupOf K ∨ b ∈ H.subgroupOf K) ↔\n ∃ a ∈ K, a ∉ H ∧ ∀ b ∈ K, a * b ∈ H ∨ b ∈ H"
] | rw [Subgroup.relIndex, Subgroup.index_eq_two_iff_exists_notMem_and'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Index | {
"line": 246,
"column": 75
} | {
"line": 247,
"column": 33
} | {
"line": 249,
"column": 0
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH : Subgroup G\nh : H.index = 2\na : G\n⊢ a * a ∈ H",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Iff.rfl",
"Membership.mem",
"id",
"MulOne.... | [] | by
rw [mul_mem_iff_of_index_two h] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Index | {
"line": 425,
"column": 2
} | {
"line": 429,
"column": 46
} | {
"line": 431,
"column": 0
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH K L : Subgroup G\n⊢ (H ⊓ K).relIndex L ≤ H.relIndex L * K.relIndex L",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"le_refl",
"Nat.instMulZeroClass",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"HMu... | [] | by_cases h : H.relIndex L = 0
· simp [relIndex_eq_zero_of_le_left inf_le_left h]
rw [← inf_relIndex_right, inf_assoc, ← relIndex_mul_relIndex _ _ L inf_le_right inf_le_right,
inf_relIndex_right, inf_relIndex_right]
grw [relIndex_le_of_le_right inf_le_right h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Index | {
"line": 425,
"column": 2
} | {
"line": 429,
"column": 46
} | {
"line": 431,
"column": 0
} | [
{
"pp": "G : Type u_1\ninst✝ : Group G\nH K L : Subgroup G\n⊢ (H ⊓ K).relIndex L ≤ H.relIndex L * K.relIndex L",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"le_refl",
"Nat.instMulZeroClass",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"HMu... | [] | by_cases h : H.relIndex L = 0
· simp [relIndex_eq_zero_of_le_left inf_le_left h]
rw [← inf_relIndex_right, inf_assoc, ← relIndex_mul_relIndex _ _ L inf_le_right inf_le_right,
inf_relIndex_right, inf_relIndex_right]
grw [relIndex_le_of_le_right inf_le_right h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.ZMod.Basic | {
"line": 128,
"column": 95
} | {
"line": 132,
"column": 86
} | {
"line": 134,
"column": 0
} | [
{
"pp": "a n : ℕ\nn0 : n ≠ 0\n⊢ addOrderOf ↑a = n / n.gcd a",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHSMul",
"instHDiv",
"ZMod.commRing",
"Nat.gcd_zero_right",
"congr... | [] | by
rcases a with - | a
· simp only [Nat.cast_zero, addOrderOf_zero, Nat.gcd_zero_right,
Nat.pos_of_ne_zero n0, Nat.div_self]
rw [← Nat.smul_one_eq_cast, addOrderOf_nsmul' _ a.succ_ne_zero, ZMod.addOrderOf_one] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.ZMod.Basic | {
"line": 154,
"column": 34
} | {
"line": 157,
"column": 6
} | {
"line": 159,
"column": 0
} | [
{
"pp": "p m n : ℕ\nh : n ≤ m\n⊢ ↑p ^ m = 0",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"CharP.cast_eq_zero",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"ZMod.commRing",
"Monoid.toMulOneClass",
"congrArg",
"CommSemi... | [] | by
obtain ⟨q, rfl⟩ := Nat.exists_eq_add_of_le h
rw [pow_add, ← Nat.cast_pow]
simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.ZMod.Basic | {
"line": 322,
"column": 2
} | {
"line": 323,
"column": 34
} | {
"line": 324,
"column": 2
} | [
{
"pp": "case succ\nR : Type u_1\ninst✝¹ : Ring R\nm : ℕ\ninst✝ : CharP R m\nn✝ : ℕ\nh : m ∣ n✝ + 1\na b : ZMod (n✝ + 1)\n⊢ ↑↑a * ↑↑b = ↑↑(a * b)",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWit... | [
"case succ\nR : Type u_1\ninst✝¹ : Ring R\nm : ℕ\ninst✝ : CharP R m\nn✝ : ℕ\nh : m ∣ n✝ + 1\na b : ZMod (n✝ + 1)\n⊢ m ∣ ↑a * ↑b - ↑a * ↑b % (n✝ + 1)"
] | rw [← Nat.cast_mul, Fin.val_mul, ← sub_eq_zero, ← Nat.cast_sub (Nat.mod_le _ _),
@CharP.cast_eq_zero_iff R _ m] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Ring.GeomSum | {
"line": 119,
"column": 2
} | {
"line": 121,
"column": 67
} | {
"line": 122,
"column": 2
} | [
{
"pp": "case refine_1\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\nn : ℕ\nx : R\nhn : n ≠ 0\nh : 0 < ∑ i ∈ range n, x ^ i\n⊢ Odd n ∨ 0 < x + 1",
"ppTerm": "?refine_1",
"assigned": true,
"usedConstants": [
"not_le",
"Eq.mpr",
"geom_sum_alte... | [
"case refine_2\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\nn : ℕ\nx : R\nhn : n ≠ 0\n⊢ Odd n ∨ 0 < x + 1 → 0 < ∑ i ∈ range n, x ^ i"
] | · rw [or_iff_not_imp_left, ← not_le, Nat.not_odd_iff_even]
refine fun hn hx => h.not_ge ?_
simpa [if_pos hn] using geom_sum_alternating_of_le_neg_one hx n | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.ZMod.Basic | {
"line": 728,
"column": 6
} | {
"line": 730,
"column": 54
} | {
"line": 731,
"column": 2
} | [] | [] | _ = a * Int.sign a := rfl
_ = a.natAbs := by rw [Int.mul_sign_self]
_ = a.natAbs.gcd 0 := by rw [Nat.gcd_zero_right] | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcSteps |
Mathlib.Data.Nat.Choose.Bounds | {
"line": 61,
"column": 6
} | {
"line": 61,
"column": 43
} | {
"line": 61,
"column": 43
} | [
{
"pp": "n k : ℕ\n⊢ (n + k).choose k ≤ (n + 1) ^ k",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"instHDiv",
"congrArg",
"Nat.instMonoid",
"Nat.ascFactorial",
"id",
"HDiv.hDiv",
"instOfNatNat",
"LE.le",
... | [
"n k : ℕ\n⊢ (n + 1).ascFactorial k / k ! ≤ (n + 1) ^ k"
] | choose_eq_asc_factorial_div_factorial | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Choose.Bounds | {
"line": 83,
"column": 14
} | {
"line": 83,
"column": 21
} | {
"line": 83,
"column": 22
} | [
{
"pp": "case neg.zero\nk : ℕ\nlt : ¬0 + 1 < k\n⊢ (0 + 1).choose k ≤ 2 ^ 0",
"ppTerm": "?neg.zero✝",
"assigned": true,
"usedConstants": [
"Nat.choose",
"Nat.instMonoid",
"instOfNatNat",
"LE.le",
"instLENat",
"Monoid.toPow",
"Nat.casesAuxOn",
"instHAdd"... | [
"case neg.zero.zero\nlt : ¬0 + 1 < 0\n⊢ (0 + 1).choose 0 ≤ 2 ^ 0",
"case neg.zero.succ\nn✝ : ℕ\nlt : ¬0 + 1 < n✝ + 1\n⊢ (0 + 1).choose (n✝ + 1) ≤ 2 ^ 0"
] | cases k | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Data.ZMod.Basic | {
"line": 894,
"column": 10
} | {
"line": 894,
"column": 22
} | {
"line": 895,
"column": 8
} | [
{
"pp": "case inl.left\nm n : ℕ\nh : Nat.Coprime 0 1\nto_fun : ZMod (0 * 1) → ZMod 0 × ZMod 1 := ⋯\ninv_fun : ZMod 0 × ZMod 1 → ZMod (0 * 1) := ⋯\nhmn0 : 0 * 1 = 0\n⊢ LeftInverse inv_fun to_fun",
"ppTerm": "?inl.left",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"instMulNat",
... | [] | intro x; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ZMod.Basic | {
"line": 894,
"column": 10
} | {
"line": 894,
"column": 22
} | {
"line": 895,
"column": 8
} | [
{
"pp": "case inl.left\nm n : ℕ\nh : Nat.Coprime 0 1\nto_fun : ZMod (0 * 1) → ZMod 0 × ZMod 1 := ⋯\ninv_fun : ZMod 0 × ZMod 1 → ZMod (0 * 1) := ⋯\nhmn0 : 0 * 1 = 0\n⊢ LeftInverse inv_fun to_fun",
"ppTerm": "?inl.left",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"instMulNat",
... | [] | intro x; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Choose.Bounds | {
"line": 98,
"column": 4
} | {
"line": 98,
"column": 11
} | {
"line": 98,
"column": 12
} | [
{
"pp": "case inl\nk : ℕ\n⊢ choose 0 k ≤ 2 ^ 0",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Nat.choose",
"Nat.instMonoid",
"instOfNatNat",
"LE.le",
"instLENat",
"Monoid.toPow",
"Nat.casesAuxOn",
"instHAdd",
"HPow.hPow",
"HAdd.h... | [
"case inl.zero\n⊢ choose 0 0 ≤ 2 ^ 0",
"case inl.succ\nn✝ : ℕ\n⊢ choose 0 (n✝ + 1) ≤ 2 ^ 0"
] | cases k | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Data.ZMod.Basic | {
"line": 899,
"column": 10
} | {
"line": 899,
"column": 22
} | {
"line": 900,
"column": 8
} | [
{
"pp": "case inr.left\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⊢ LeftInverse inv_fun to_fun",
"ppTerm": "?inr.left",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"instMulNat",
... | [] | intro x; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ZMod.Basic | {
"line": 899,
"column": 10
} | {
"line": 899,
"column": 22
} | {
"line": 900,
"column": 8
} | [
{
"pp": "case inr.left\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⊢ LeftInverse inv_fun to_fun",
"ppTerm": "?inr.left",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"instMulNat",
... | [] | intro x; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.ZMod.Basic | {
"line": 975,
"column": 19
} | {
"line": 975,
"column": 29
} | {
"line": 976,
"column": 2
} | [
{
"pp": "hn : 1 < 0\nx✝ : ZMod 0\n⊢ x✝.val = 1 ↔ x✝ = 1",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"not_lt_zero._simp_1",
"False",
"Nat.instMulZeroClass",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"ZMod.commRing",
"False.elim",
"AddG... | [] | simp at hn | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.ZMod.Basic | {
"line": 975,
"column": 19
} | {
"line": 975,
"column": 29
} | {
"line": 976,
"column": 2
} | [
{
"pp": "hn : 1 < 0\nx✝ : ZMod 0\n⊢ x✝.val = 1 ↔ x✝ = 1",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"not_lt_zero._simp_1",
"False",
"Nat.instMulZeroClass",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"ZMod.commRing",
"False.elim",
"AddG... | [] | simp at hn | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ZMod.Basic | {
"line": 975,
"column": 19
} | {
"line": 975,
"column": 29
} | {
"line": 976,
"column": 2
} | [
{
"pp": "hn : 1 < 0\nx✝ : ZMod 0\n⊢ x✝.val = 1 ↔ x✝ = 1",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"not_lt_zero._simp_1",
"False",
"Nat.instMulZeroClass",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"ZMod.commRing",
"False.elim",
"AddG... | [] | simp at hn | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.ZMod.Basic | {
"line": 975,
"column": 19
} | {
"line": 975,
"column": 29
} | {
"line": 976,
"column": 2
} | [
{
"pp": "hn : 1 < 1\nx✝ : ZMod 1\n⊢ x✝.val = 1 ↔ x✝ = 1",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"False",
"ZMod.commRing",
"False.elim",
"AddGroupWithOne.toAddMonoidWithOne",
"lt_self_iff_false._simp_1",
"Eq.mp",
"instOfNatNat",
"ZMod"... | [] | simp at hn | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.ZMod.Basic | {
"line": 975,
"column": 19
} | {
"line": 975,
"column": 29
} | {
"line": 976,
"column": 2
} | [
{
"pp": "hn : 1 < 1\nx✝ : ZMod 1\n⊢ x✝.val = 1 ↔ x✝ = 1",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"False",
"ZMod.commRing",
"False.elim",
"AddGroupWithOne.toAddMonoidWithOne",
"lt_self_iff_false._simp_1",
"Eq.mp",
"instOfNatNat",
"ZMod"... | [] | simp at hn | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ZMod.Basic | {
"line": 975,
"column": 19
} | {
"line": 975,
"column": 29
} | {
"line": 976,
"column": 2
} | [
{
"pp": "hn : 1 < 1\nx✝ : ZMod 1\n⊢ x✝.val = 1 ↔ x✝ = 1",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"False",
"ZMod.commRing",
"False.elim",
"AddGroupWithOne.toAddMonoidWithOne",
"lt_self_iff_false._simp_1",
"Eq.mp",
"instOfNatNat",
"ZMod"... | [] | simp at hn | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Digits.Defs | {
"line": 265,
"column": 19
} | {
"line": 265,
"column": 53
} | {
"line": 267,
"column": 0
} | [
{
"pp": "case cons\nhead✝ : ℕ\ntail✝ : List ℕ\nih : ofDigits 1 tail✝ = tail✝.sum\n⊢ ofDigits 1 (head✝ :: tail✝) = (head✝ :: tail✝).sum",
"ppTerm": "?cons",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"HMul.hMul",
"congrArg",
"Nat.ofDigits",
"List.sum",
... | [] | simp [ofDigits, List.sum_cons, ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Nat.Digits.Defs | {
"line": 265,
"column": 19
} | {
"line": 265,
"column": 53
} | {
"line": 267,
"column": 0
} | [
{
"pp": "case cons\nhead✝ : ℕ\ntail✝ : List ℕ\nih : ofDigits 1 tail✝ = tail✝.sum\n⊢ ofDigits 1 (head✝ :: tail✝) = (head✝ :: tail✝).sum",
"ppTerm": "?cons",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"HMul.hMul",
"congrArg",
"Nat.ofDigits",
"List.sum",
... | [] | simp [ofDigits, List.sum_cons, ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Digits.Defs | {
"line": 265,
"column": 19
} | {
"line": 265,
"column": 53
} | {
"line": 267,
"column": 0
} | [
{
"pp": "case cons\nhead✝ : ℕ\ntail✝ : List ℕ\nih : ofDigits 1 tail✝ = tail✝.sum\n⊢ ofDigits 1 (head✝ :: tail✝) = (head✝ :: tail✝).sum",
"ppTerm": "?cons",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"HMul.hMul",
"congrArg",
"Nat.ofDigits",
"List.sum",
... | [] | simp [ofDigits, List.sum_cons, ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.MaxPowDiv | {
"line": 154,
"column": 4
} | {
"line": 154,
"column": 31
} | {
"line": 156,
"column": 0
} | [
{
"pp": "case inr\np k a b : ℕ\nhp : 1 < p\nhb : ¬p ∣ b\nhn : p ^ a * b ≠ 0\nhle : a ≥ k\n⊢ p ^ k ∣ p ^ a",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"Nat.pow_dvd_pow"
],
"usedFVars": [
"k",
"a",
"p",
"hle"
],
"usedGoals": []
}
] | [] | exact Nat.pow_dvd_pow p hle | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 60,
"column": 4
} | {
"line": 64,
"column": 24
} | {
"line": 66,
"column": 0
} | [
{
"pp": "case neg\nb : ℕ\nhb : 1 < b\nn : ℕ\nIH : ∀ m < n, m ≠ 0 → (b.digits m).length = log b m + 1\nhn : n ≠ 0\nh : ¬n / b = 0\n⊢ (b.digits (n / b)).length + 1 = log b n + 1",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Math... | [] | have : n / b < n := div_lt_self (Nat.pos_of_ne_zero hn) hb
rw [IH _ this h, log_div_base, tsub_add_cancel_of_le]
refine Nat.succ_le_of_lt (log_pos hb ?_)
contrapose! h
exact div_eq_of_lt h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 60,
"column": 4
} | {
"line": 64,
"column": 24
} | {
"line": 66,
"column": 0
} | [
{
"pp": "case neg\nb : ℕ\nhb : 1 < b\nn : ℕ\nIH : ∀ m < n, m ≠ 0 → (b.digits m).length = log b m + 1\nhn : n ≠ 0\nh : ¬n / b = 0\n⊢ (b.digits (n / b)).length + 1 = log b n + 1",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Math... | [] | have : n / b < n := div_lt_self (Nat.pos_of_ne_zero hn) hb
rw [IH _ this h, log_div_base, tsub_add_cancel_of_le]
refine Nat.succ_le_of_lt (log_pos hb ?_)
contrapose! h
exact div_eq_of_lt h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 108,
"column": 4
} | {
"line": 109,
"column": 69
} | {
"line": 111,
"column": 0
} | [
{
"pp": "case neg\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": "?neg✝",
"assigned": true,
"usedConstants": [
"List.getLast",
"List.getLast_append_of_right_ne_nil",
... | [] | · exact (List.getLast_append_of_right_ne_nil _ _ h) ▸
(getLast_digit_ne_zero _ <| digits_ne_nil_iff_ne_zero.mp h) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Nat.Digits.Defs | {
"line": 427,
"column": 4
} | {
"line": 427,
"column": 15
} | {
"line": 428,
"column": 6
} | [
{
"pp": "case succ.succ\nn p : ℕ\na✝¹ : (p.digits n).sum ≤ n → (p.digits (n + 1)).sum ≤ n + 1\na✝ : ((p + 1).digits n).sum ≤ n\n⊢ ((p + 1).digits (n + 1)).sum ≤ n + 1",
"ppTerm": "?succ.succ",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instMulZeroClass",
"Nat.ofDigits_one"... | [] | | succ p => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 163,
"column": 2
} | {
"line": 168,
"column": 27
} | {
"line": 170,
"column": 0
} | [
{
"pp": "d n : ℕ\nhd : d ≠ 0\nhn : n ≠ 0\n⊢ d.factorization ≤ n.factorization ↔ d ∣ n",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Finsupp.instCanonicallyOrderedAddOfAddLeftMono",
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Finsupp.i... | [] | refine ⟨fun hdn ↦ ?_, fun ⟨c, h⟩ ↦ ?_⟩
· rw [← prod_factorization_pow_eq_self hn, ← prod_factorization_pow_eq_self hd]
exact prod_dvd_prod_of_subset_of_dvd (support_mono hdn) fun a _ ↦ pow_dvd_pow a (hdn a)
· subst h
rw [factorization_mul hd <| right_ne_zero_of_mul hn]
apply self_le_add_right | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 163,
"column": 2
} | {
"line": 168,
"column": 27
} | {
"line": 170,
"column": 0
} | [
{
"pp": "d n : ℕ\nhd : d ≠ 0\nhn : n ≠ 0\n⊢ d.factorization ≤ n.factorization ↔ d ∣ n",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Finsupp.instCanonicallyOrderedAddOfAddLeftMono",
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Finsupp.i... | [] | refine ⟨fun hdn ↦ ?_, fun ⟨c, h⟩ ↦ ?_⟩
· rw [← prod_factorization_pow_eq_self hn, ← prod_factorization_pow_eq_self hd]
exact prod_dvd_prod_of_subset_of_dvd (support_mono hdn) fun a _ ↦ pow_dvd_pow a (hdn a)
· subst h
rw [factorization_mul hd <| right_ne_zero_of_mul hn]
apply self_le_add_right | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 185,
"column": 2
} | {
"line": 191,
"column": 35
} | {
"line": 193,
"column": 0
} | [
{
"pp": "n k : ℕ\n⊢ (n ^ k).factorization = k • n.factorization",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"instPowNat",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"MulOne.toOne",
"False",
"Nat.instMulZeroClass",
"Nat.recAux",
"instHSMul... | [] | induction k with
| zero => simp
| succ k ih =>
rcases eq_or_ne n 0 with (rfl | hn)
· simp
rw [Nat.pow_succ, mul_comm, factorization_mul hn (pow_ne_zero _ hn), ih,
add_smul, one_smul, add_comm] | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 185,
"column": 2
} | {
"line": 191,
"column": 35
} | {
"line": 193,
"column": 0
} | [
{
"pp": "n k : ℕ\n⊢ (n ^ k).factorization = k • n.factorization",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"instPowNat",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"MulOne.toOne",
"False",
"Nat.instMulZeroClass",
"Nat.recAux",
"instHSMul... | [] | induction k with
| zero => simp
| succ k ih =>
rcases eq_or_ne n 0 with (rfl | hn)
· simp
rw [Nat.pow_succ, mul_comm, factorization_mul hn (pow_ne_zero _ hn), ih,
add_smul, one_smul, add_comm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factorization.Defs | {
"line": 185,
"column": 2
} | {
"line": 191,
"column": 35
} | {
"line": 193,
"column": 0
} | [
{
"pp": "n k : ℕ\n⊢ (n ^ k).factorization = k • n.factorization",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"instPowNat",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"MulOne.toOne",
"False",
"Nat.instMulZeroClass",
"Nat.recAux",
"instHSMul... | [] | induction k with
| zero => simp
| succ k ih =>
rcases eq_or_ne n 0 with (rfl | hn)
· simp
rw [Nat.pow_succ, mul_comm, factorization_mul hn (pow_ne_zero _ hn), ih,
add_smul, one_smul, add_comm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Multiplicity | {
"line": 197,
"column": 2
} | {
"line": 197,
"column": 9
} | {
"line": 198,
"column": 2
} | [
{
"pp": "α : Type u_1\ninst✝ : Monoid α\na b : α\nk : ℕ\nhk : ↑k ≤ emultiplicity a b\n⊢ a ^ k ∣ b",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Dvd.dvd",
"ENat.instNatCast",
"semigroupDvd",
"instOfNatNat",
"LE.le",
"Nat.cast",
"instLEENat",
... | [
"case zero\nα : Type u_1\ninst✝ : Monoid α\na b : α\nhk : ↑0 ≤ emultiplicity a b\n⊢ a ^ 0 ∣ b",
"case succ\nα : Type u_1\ninst✝ : Monoid α\na b : α\nn✝ : ℕ\nhk : ↑(n✝ + 1) ≤ emultiplicity a b\n⊢ a ^ (n✝ + 1) ∣ b"
] | cases k | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Data.Nat.Digits.Lemmas | {
"line": 434,
"column": 2
} | {
"line": 434,
"column": 34
} | {
"line": 435,
"column": 2
} | [
{
"pp": "b : ℕ\nhb : 1 < b\nl : ℕ\n⊢ Set.BijOn (b.digitsAppend l) ↑(Finset.range (b ^ l)) {L | L.length = l ∧ ∀ x ∈ L, x < b}",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HEq.refl",
"Finset",
"Nat.instMonoid",
"Nat.digitsAppend",
"setOf",
... | [
"b : ℕ\nhb : 1 < b\nl : ℕ\n⊢ ↑(Finset.range (b ^ l)) = {n | n < b ^ l}"
] | convert! bijOn_digitsAppend hb l | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___macroRules_Mathlib_Tactic_convert!_1 | Mathlib.Tactic.convert! |
Mathlib.Data.Nat.Factorization.Basic | {
"line": 483,
"column": 2
} | {
"line": 483,
"column": 48
} | {
"line": 484,
"column": 2
} | [
{
"pp": "n : ℕ\nhn : n ≠ 0\n⊢ (n.factorization.prod fun x1 x2 ↦ x1 ^ x2) = ∏ p, ↑p ^ n.factorization ↑p",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instMulZeroClass",
"Finset.univ",
"congrArg",
"Finset",
"N... | [
"n : ℕ\nhn : n ≠ 0\n⊢ ∏ p ∈ n.primeFactors, p ^ n.factorization p = ∏ p, ↑p ^ n.factorization ↑p"
] | rw [prod_factorization_eq_prod_primeFactors _] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.OrderOfElement | {
"line": 1021,
"column": 2
} | {
"line": 1021,
"column": 25
} | {
"line": 1022,
"column": 2
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Monoid G\ninst✝ : Finite Gˣ\nx : G\n⊢ IsOfFinOrder x ↔ IsUnit x",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"IsUnit",
"Iff.intro",
"IsOfFinOrder.isUnit",
"IsOfFinOrder"
],
"usedFVars": [
"G",
"inst✝¹",
"x"... | [
"case mpr\nG : Type u_1\ninst✝¹ : Monoid G\ninst✝ : Finite Gˣ\nx : G\n⊢ IsUnit x → IsOfFinOrder x"
] | use IsOfFinOrder.isUnit | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.GroupTheory.OrderOfElement | {
"line": 1220,
"column": 4
} | {
"line": 1221,
"column": 67
} | {
"line": 1222,
"column": 2
} | [
{
"pp": "G✝ : Type u_1\nH : Type u_2\nA : Type u_3\nα : Type u_4\nβ : Type u_5\ninst✝² : Group G✝\nx✝ y : G✝\ninst✝¹ : Fintype G✝\nx : G✝\nn : ℕ\nG : Type u_6\ninst✝ : Group G\nh : (Nat.card G).Coprime n\ng : G\nkey : g ^ ↑((Nat.card G).gcd n) = g ^ (↑(Nat.card G) * (Nat.card G).gcdA n + ↑n * (Nat.card G).gcdB ... | [] | rwa [zpow_add, zpow_mul, zpow_mul, zpow_natCast, zpow_natCast, zpow_natCast, h.gcd_eq_one,
pow_one, pow_card_eq_one', one_zpow, one_mul, eq_comm] at key | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Algebra.Polynomial.Inductions | {
"line": 174,
"column": 55
} | {
"line": 174,
"column": 60
} | {
"line": 174,
"column": 61
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\nP : R[X] → Prop\np✝ : R[X]\nh0✝ : 0 < p✝.degree\nhC : ∀ {a : R}, a ≠ 0 → P (C a * X)\nhX : ∀ {p : R[X]}, 0 < p.degree → P p → P (p * X)\nhadd : ∀ {p : R[X]} {a : R}, 0 < p.degree → P p → P (p + C a)\np : R[X]\na : R\nheq0 : p.coeff 0 = 0\nx✝ : a ≠ 0\nih : 0 < p.degree → ... | [
"R : Type u\ninst✝ : Semiring R\nP : R[X] → Prop\np✝ : R[X]\nh0✝ : 0 < p✝.degree\nhC : ∀ {a : R}, a ≠ 0 → P (C a * X)\nhX : ∀ {p : R[X]}, 0 < p.degree → P p → P (p * X)\nhadd : ∀ {p : R[X]} {a : R}, 0 < p.degree → P p → P (p + C a)\np : R[X]\na : R\nheq0 : p.coeff 0 = 0\nx✝ : a ≠ 0\nih : 0 < p.degree → P p\nh0 : 0 ... | heq0, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 52,
"column": 11
} | {
"line": 53,
"column": 94
} | {
"line": 55,
"column": 0
} | [
{
"pp": "R : Type u\nS : Type v\nT : Type w\nι : Type y\nA : Type z\na✝ b : R\nn : ℕ\ninst✝ : Semiring R\np✝ : R[X]\na : R\np : R[X]\n⊢ ((a • p).sum fun n a ↦ C (a * ↑n) * X ^ (n - 1)) = a • p.sum fun n a ↦ C (a * ↑n) * X ^ (n - 1)",
"ppTerm": "?m.84",
"assigned": true,
"usedConstants": [
"Eq.... | [] | rw [sum_smul_index] <;>
simp only [mul_sum, ← C_mul', mul_assoc, map_mul, forall_const, zero_mul, map_zero, sum] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.Polynomial.RingDivision | {
"line": 207,
"column": 4
} | {
"line": 212,
"column": 26
} | {
"line": 214,
"column": 0
} | [] | [] | ((-1) ^ p.natDegree * p.comp (-X)).leadingCoeff =
(p.comp (-X) * C ((-1) ^ p.natDegree)).leadingCoeff := by
simp [mul_comm]
_ = 1 := by
apply monic_mul_C_of_leadingCoeff_mul_eq_one
simp [← pow_add, hp] | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcSteps |
Mathlib.Algebra.Polynomial.Expand | {
"line": 84,
"column": 49
} | {
"line": 84,
"column": 60
} | {
"line": 84,
"column": 61
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\np q : ℕ\nf : R[X]\nn : ℕ\nih : (expand R (p ^ n)) f = (⇑(expand R p))^[n] f\n⊢ (expand R (p * p ^ n)) f = (expand R p) ((⇑(expand R p))^[n] f)",
"ppTerm": "?m.43",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Monoid.toMul... | [
"R : Type u\ninst✝ : CommSemiring R\np q : ℕ\nf : R[X]\nn : ℕ\nih : (expand R (p ^ n)) f = (⇑(expand R p))^[n] f\n⊢ (expand R p) ((expand R (p ^ n)) f) = (expand R p) ((⇑(expand R p))^[n] f)"
] | expand_mul, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 148,
"column": 17
} | {
"line": 148,
"column": 26
} | {
"line": 150,
"column": 0
} | [
{
"pp": "case succ\nR : Type u\ninst✝² : Semiring R\nS : Type u_1\ninst✝¹ : SMulZeroClass S R\ninst✝ : IsScalarTower S R R\ns : S\nk : ℕ\nih : ∀ (p : R[X]), (⇑derivative)^[k] (s • p) = s • (⇑derivative)^[k] p\np : R[X]\n⊢ (⇑derivative)^[k + 1] (s • p) = s • (⇑derivative)^[k + 1] p",
"ppTerm": "?succ",
"... | [] | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 148,
"column": 17
} | {
"line": 148,
"column": 26
} | {
"line": 150,
"column": 0
} | [
{
"pp": "case succ\nR : Type u\ninst✝² : Semiring R\nS : Type u_1\ninst✝¹ : SMulZeroClass S R\ninst✝ : IsScalarTower S R R\ns : S\nk : ℕ\nih : ∀ (p : R[X]), (⇑derivative)^[k] (s • p) = s • (⇑derivative)^[k] p\np : R[X]\n⊢ (⇑derivative)^[k + 1] (s • p) = s • (⇑derivative)^[k + 1] p",
"ppTerm": "?succ",
"... | [] | simp [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 148,
"column": 17
} | {
"line": 148,
"column": 26
} | {
"line": 150,
"column": 0
} | [
{
"pp": "case succ\nR : Type u\ninst✝² : Semiring R\nS : Type u_1\ninst✝¹ : SMulZeroClass S R\ninst✝ : IsScalarTower S R R\ns : S\nk : ℕ\nih : ∀ (p : R[X]), (⇑derivative)^[k] (s • p) = s • (⇑derivative)^[k] p\np : R[X]\n⊢ (⇑derivative)^[k + 1] (s • p) = s • (⇑derivative)^[k + 1] p",
"ppTerm": "?succ",
"... | [] | simp [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 209,
"column": 2
} | {
"line": 209,
"column": 31
} | {
"line": 210,
"column": 2
} | [
{
"pp": "case h\nR : Type u\ninst✝ : Semiring R\np : R[X]\nih : ∀ m < p.natDegree, ∀ {p : R[X]} {x : ℕ}, p.natDegree < x → p.natDegree = m → (⇑derivative)^[x] p = 0\nt : ℕ\nhx : p.natDegree < t.succ\n⊢ (⇑derivative)^[t] (derivative p) = 0",
"ppTerm": "?h",
"assigned": true,
"usedConstants": [
... | [
"case pos\nR : Type u\ninst✝ : Semiring R\np : R[X]\nih : ∀ m < p.natDegree, ∀ {p : R[X]} {x : ℕ}, p.natDegree < x → p.natDegree = m → (⇑derivative)^[x] p = 0\nt : ℕ\nhx : p.natDegree < t.succ\nhp : p.natDegree = 0\n⊢ (⇑derivative)^[t] (derivative p) = 0",
"case neg\nR : Type u\ninst✝ : Semiring R\np : R[X]\nih :... | by_cases hp : p.natDegree = 0 | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Algebra.Polynomial.Div | {
"line": 177,
"column": 4
} | {
"line": 177,
"column": 44
} | {
"line": 178,
"column": 4
} | [
{
"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",
... | [
"case neg\nR : Type u\ninst✝ : Ring R\np q : R[X]\nhmq : q.Monic\nhq : q ≠ 1\nhpq : ¬p %ₘ q = 0\nthis : Nontrivial R\n⊢ (p %ₘ q).natDegree < q.natDegree"
] | haveI := Nontrivial.of_polynomial_ne hpq | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHaveI___1 | Lean.Parser.Tactic.tacticHaveI__ |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 236,
"column": 2
} | {
"line": 241,
"column": 19
} | {
"line": 243,
"column": 0
} | [
{
"pp": "case monomial.monomial\nR : Type u\ninst✝ : Semiring R\nm : ℕ\na : R\nn : ℕ\nb : R\n⊢ (monomial (m + n - 1)) (a * (b * ↑m)) + (monomial (m + n - 1)) (a * (b * ↑n)) =\n (monomial (m - 1 + n)) (a * (b * ↑m)) + (monomial (m + (n - 1))) (a * (b * ↑n))",
"ppTerm": "?monomial.monomial",
"assigned"... | [] | cases m with
| zero => simp only [zero_add, Nat.cast_zero, mul_zero, map_zero]
| succ m =>
cases n with
| zero => simp only [add_zero, Nat.cast_zero, mul_zero, map_zero]
| succ n => grind | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.RingTheory.Polynomial.Tower | {
"line": 94,
"column": 2
} | {
"line": 94,
"column": 24
} | {
"line": 96,
"column": 0
} | [
{
"pp": "R : Type u_1\nA : Type u_2\ninst✝² : CommSemiring R\ninst✝¹ : CommRing A\ninst✝ : Algebra R A\ns : Multiset A\nx : A\nhx : x ∈ s\np : R[X]\nhp : (mapAlg R A) p = (Multiset.map (fun x ↦ X - C x) s).prod\n⊢ ∃ a ∈ s, (⇑(aeval x) ∘ fun x ↦ X - C x) a = 0",
"ppTerm": "?m.91",
"assigned": true,
"... | [] | exact ⟨x, hx, by simp⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 424,
"column": 2
} | {
"line": 424,
"column": 31
} | {
"line": 425,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝¹ : Semiring R\ninst✝ : IsAddTorsionFree R\np : R[X]\n⊢ (derivative p).natDegree = p.natDegree - 1",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Polynomial.derivative",
"Semiring.toModule",
"LinearMap.instFunLike",
"HSub.hSub",
"in... | [
"case pos\nR : Type u\ninst✝¹ : Semiring R\ninst✝ : IsAddTorsionFree R\np : R[X]\nhp : p.natDegree = 0\n⊢ (derivative p).natDegree = p.natDegree - 1",
"case neg\nR : Type u\ninst✝¹ : Semiring R\ninst✝ : IsAddTorsionFree R\np : R[X]\nhp : ¬p.natDegree = 0\n⊢ (derivative p).natDegree = p.natDegree - 1"
] | by_cases hp : p.natDegree = 0 | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 449,
"column": 2
} | {
"line": 449,
"column": 31
} | {
"line": 450,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝¹ : Semiring R\ninst✝ : IsAddTorsionFree R\np : R[X]\n⊢ (derivative p).leadingCoeff = p.leadingCoeff * ↑p.natDegree",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Polynomial.derivative",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Semiring.toMo... | [
"case pos\nR : Type u\ninst✝¹ : Semiring R\ninst✝ : IsAddTorsionFree R\np : R[X]\nhp : p.natDegree = 0\n⊢ (derivative p).leadingCoeff = p.leadingCoeff * ↑p.natDegree",
"case neg\nR : Type u\ninst✝¹ : Semiring R\ninst✝ : IsAddTorsionFree R\np : R[X]\nhp : ¬p.natDegree = 0\n⊢ (derivative p).leadingCoeff = p.leading... | by_cases hp : p.natDegree = 0 | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Algebra.Polynomial.Div | {
"line": 479,
"column": 2
} | {
"line": 479,
"column": 31
} | {
"line": 480,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\np : R[X]\na : R\nn : ℕ\nh : p.natDegree ≤ n\na✝ : Nontrivial R\n⊢ (p /ₘ (X - C a)).coeff n = 0",
"ppTerm": "?m.246",
"assigned": true,
"usedConstants": [
"Polynomial.C",
"AddMonoid.toAddZeroClass",
"HSub.hSub",
"RingHom",
"AddZeroCla... | [
"case pos\nR : Type u\ninst✝ : Ring R\np : R[X]\na : R\nn : ℕ\nh : p.natDegree ≤ n\na✝ : Nontrivial R\nhp : p.natDegree = 0\n⊢ (p /ₘ (X - C a)).coeff n = 0",
"case neg\nR : Type u\ninst✝ : Ring R\np : R[X]\na : R\nn : ℕ\nh : p.natDegree ≤ n\na✝ : Nontrivial R\nhp : ¬p.natDegree = 0\n⊢ (p /ₘ (X - C a)).coeff n = 0... | by_cases hp : p.natDegree = 0 | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Algebra.Polynomial.Div | {
"line": 590,
"column": 2
} | {
"line": 591,
"column": 63
} | {
"line": 592,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\na : R\na✝ : Nontrivial R\nh : eval a (p %ₘ (X - C a)) = eval a p\n⊢ p %ₘ (X - C a) = C (eval a p)",
"ppTerm": "?m.51",
"assigned": true,
"usedConstants": [
"Polynomial.monic_X_sub_C",
"WithBot.instPreorder",
"Polynomial.C",
"... | [
"R : Type u\ninst✝ : CommRing R\np : R[X]\na : R\na✝ : Nontrivial R\nh : eval a (p %ₘ (X - C a)) = eval a p\nthis : (p %ₘ (X - C a)).degree < 1\n⊢ p %ₘ (X - C a) = C (eval a p)"
] | have : degree (p %ₘ (X - C a)) < 1 :=
degree_X_sub_C a ▸ degree_modByMonic_lt p (monic_X_sub_C a) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.BigOperators.Associated | {
"line": 66,
"column": 4
} | {
"line": 66,
"column": 33
} | {
"line": 67,
"column": 4
} | [
{
"pp": "case empty\nM : Type u_4\ninst✝ : CommMonoid M\nι : Type u_5\nf g : ι → M\nh : ∀ i ∈ ∅, f i ~ᵤ g i\n⊢ ∏ i ∈ ∅, f i ~ᵤ ∏ i ∈ ∅, g i",
"ppTerm": "?empty",
"assigned": true,
"usedConstants": [
"Finset",
"id",
"Finset.instEmptyCollection",
"Finset.prod",
"Associate... | [
"case empty\nM : Type u_4\ninst✝ : CommMonoid M\nι : Type u_5\nf g : ι → M\nh : ∀ i ∈ ∅, f i ~ᵤ g i\n⊢ 1 ~ᵤ 1"
] | simp only [Finset.prod_empty] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.BigOperators.Associated | {
"line": 71,
"column": 4
} | {
"line": 71,
"column": 30
} | {
"line": 73,
"column": 0
} | [
{
"pp": "case insert\nM : Type u_4\ninst✝ : CommMonoid M\nι : Type u_5\ns✝ : Finset ι\nf g : ι → M\nj : ι\ns : Finset ι\nhjs : j ∉ s\nIH : (∀ i ∈ s, f i ~ᵤ g i) → ∏ i ∈ s, f i ~ᵤ ∏ i ∈ s, g i\nh : ∀ i ∈ insert j s, f i ~ᵤ g i\n⊢ ∏ i ∈ insert j s, f i ~ᵤ ∏ i ∈ insert j s, g i",
"ppTerm": "?insert",
"assi... | [] | grind [Associated.mul_mul] | Lean.Elab.Tactic.evalGrind | Lean.Parser.Tactic.grind |
Mathlib.Algebra.BigOperators.Associated | {
"line": 89,
"column": 50
} | {
"line": 121,
"column": 72
} | {
"line": 123,
"column": 0
} | [
{
"pp": "M₀ : Type u_3\ninst✝¹ : CommMonoidWithZero M₀\ninst✝ : IsCancelMulZero M₀\nx y : M₀\nhxy : x * y ∈ closure {r | IsUnit r ∨ Prime r}\n⊢ x ∈ closure {r | IsUnit r ∨ Prime r}",
"ppTerm": "?m.27",
"assigned": true,
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Iff.mpr",
... | [] | by
obtain ⟨m, hm, hprod⟩ := exists_multiset_of_mem_closure hxy
induction m using Multiset.induction generalizing x y with
| empty =>
apply subset_closure
push _ ∈ _
simp only [Multiset.prod_zero] at hprod
left; exact .of_mul_eq_one _ hprod.symm
| cons c s hind =>
simp only [Multiset.mem_cons... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Div | {
"line": 737,
"column": 50
} | {
"line": 737,
"column": 68
} | {
"line": 737,
"column": 68
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\np0 : p ≠ 0\na : R\nn : ℕ\n⊢ rootMultiplicity a p ≤ n ↔ rootMultiplicity a p < n + 1",
"ppTerm": "?m.48",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"PartialOrder.toPreorder",
"Nat.lt_add... | [
"R : Type u\ninst✝ : CommRing R\np : R[X]\np0 : p ≠ 0\na : R\nn : ℕ\n⊢ rootMultiplicity a p ≤ n ↔ rootMultiplicity a p ≤ n"
] | Nat.lt_add_one_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 120,
"column": 36
} | {
"line": 123,
"column": 15
} | {
"line": 125,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\nx : α\nhx : x ≠ 0\nh : ¬IsUnit x\n⊢ ∃ p, p ∈ normalizedFactors x",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"UniqueFactorizationMonoid.normalizedFactors",
... | [] | by
obtain ⟨p', hp', hp'x⟩ := WfDvdMonoid.exists_irreducible_factor h hx
obtain ⟨p, hp, _⟩ := exists_mem_normalizedFactors_of_dvd hx hp' hp'x
exact ⟨p, hp⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 194,
"column": 57
} | {
"line": 200,
"column": 38
} | {
"line": 202,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\nx y : α\nhx : x ≠ 0\nhy : y ≠ 0\n⊢ x ∣ y ↔ normalizedFactors x ≤ normalizedFactors y",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"UniqueFactorizationMonoid.n... | [] | by
constructor
· rintro ⟨c, rfl⟩
simp [hx, right_ne_zero_of_mul hy]
· rw [← (prod_normalizedFactors hx).dvd_iff_dvd_left, ←
(prod_normalizedFactors hy).dvd_iff_dvd_right]
apply Multiset.prod_dvd_prod_of_le | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Roots | {
"line": 244,
"column": 17
} | {
"line": 247,
"column": 31
} | {
"line": 249,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\nb : R\na : Rˣ\n⊢ (C ↑a * X - C b).roots = {↑a⁻¹ * b}",
"ppTerm": "?m.38",
"assigned": true,
"usedConstants": [
"Units.val",
"Eq.mpr",
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",... | [] | by
rw [← roots_C_mul _ (Units.ne_zero a⁻¹), mul_sub, ← mul_assoc, ← C_mul, ← C_mul,
Units.inv_mul, C_1, one_mul]
exact roots_X_sub_C (a⁻¹ * b) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Polynomial.Content | {
"line": 70,
"column": 2
} | {
"line": 70,
"column": 95
} | {
"line": 71,
"column": 2
} | [
{
"pp": "R : Type u_1\ninst✝¹ : CommSemiring R\ninst✝ : NoZeroDivisors R\np : R[X]\nhp : Irreducible p\nhp' : p.natDegree ≠ 0\nr : R\nq : R[X]\nhq : p = C r * q\n⊢ IsUnit r",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"Polynomial.C",
"RingHom.instRingHomClass",
"congrA... | [
"R : Type u_1\ninst✝¹ : CommSemiring R\ninst✝ : NoZeroDivisors R\np : R[X]\nhp : Irreducible p\nhp' : p.natDegree ≠ 0\nr : R\nq : R[X]\nhq : p = C r * q\n⊢ ¬IsUnit q"
] | suffices ¬IsUnit q by simpa using ((hp.2 hq).resolve_right this).map Polynomial.constantCoeff | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSuffices__1 | Lean.Parser.Tactic.tacticSuffices_ |
Mathlib.Algebra.Polynomial.Roots | {
"line": 453,
"column": 2
} | {
"line": 456,
"column": 33
} | {
"line": 458,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝² : CommRing R\ninst✝¹ : IsDomain R\ninst✝ : Infinite R\np q : R[X]\next : ∀ (r : R), eval r p = eval r q\n⊢ p = q",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"Polynomial.eval",
"AddGroupWithOne... | [] | rw [← sub_eq_zero]
apply zero_of_eval_zero
intro x
rw [eval_sub, sub_eq_zero, ext] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Roots | {
"line": 453,
"column": 2
} | {
"line": 456,
"column": 33
} | {
"line": 458,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝² : CommRing R\ninst✝¹ : IsDomain R\ninst✝ : Infinite R\np q : R[X]\next : ∀ (r : R), eval r p = eval r q\n⊢ p = q",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"Polynomial.eval",
"AddGroupWithOne... | [] | rw [← sub_eq_zero]
apply zero_of_eval_zero
intro x
rw [eval_sub, sub_eq_zero, ext] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Roots | {
"line": 760,
"column": 4
} | {
"line": 760,
"column": 32
} | {
"line": 762,
"column": 0
} | [
{
"pp": "case inr\nR : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\nf : R[X]\nhf : ∀ (r : R), eval r f = 0\nhfR : ↑f.natDegree < #R\nhR : Infinite R\n⊢ f = 0",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"Polynomial.zero_of_eval_zero"
],
"usedFVars": [
"R",
"... | [] | exact zero_of_eval_zero _ hf | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Polynomial.Roots | {
"line": 760,
"column": 4
} | {
"line": 760,
"column": 32
} | {
"line": 762,
"column": 0
} | [
{
"pp": "case inr\nR : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\nf : R[X]\nhf : ∀ (r : R), eval r f = 0\nhfR : ↑f.natDegree < #R\nhR : Infinite R\n⊢ f = 0",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"Polynomial.zero_of_eval_zero"
],
"usedFVars": [
"R",
"... | [] | exact zero_of_eval_zero _ hf | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Roots | {
"line": 760,
"column": 4
} | {
"line": 760,
"column": 32
} | {
"line": 762,
"column": 0
} | [
{
"pp": "case inr\nR : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\nf : R[X]\nhf : ∀ (r : R), eval r f = 0\nhfR : ↑f.natDegree < #R\nhR : Infinite R\n⊢ f = 0",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"Polynomial.zero_of_eval_zero"
],
"usedFVars": [
"R",
"... | [] | exact zero_of_eval_zero _ hf | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Polynomial.Content | {
"line": 283,
"column": 32
} | {
"line": 286,
"column": 58
} | {
"line": 288,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝³ : CommRing R\ninst✝² : NormalizedGCDMonoid R\nS : Type u_2\ninst✝¹ : CommSemiring S\ninst✝ : IsDomain S\nf : R →+* S\nhinj : Function.Injective ⇑f\np : R[X]\ns : S\nhpzero : p ≠ 0\nhp : eval₂ f s p = 0\n⊢ eval₂ f s p.primPart = 0",
"ppTerm": "?m.29",
"assigned": true,
"... | [] | by
rw [eq_C_content_mul_primPart p, eval₂_mul, eval₂_C] at hp
refine eq_zero_of_ne_zero_of_mul_left_eq_zero ?_ hp
rwa [hinj.ne_iff' (map_zero _), Ne, content_eq_zero_iff] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.FieldDivision | {
"line": 699,
"column": 6
} | {
"line": 699,
"column": 32
} | {
"line": 699,
"column": 33
} | [
{
"pp": "case neg\nR : Type u\ninst✝¹ : Field R\ninst✝ : DecidableEq R\na : R[X]\nha : ¬a = 0\n⊢ C a.leadingCoeff * (normalizedFactors a).prod = a",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Polynomial.instNormalizationMonoid",
"UniqueFactorizationMonoid.normalizedFactors"... | [
"case neg\nR : Type u\ninst✝¹ : Field R\ninst✝ : DecidableEq R\na : R[X]\nha : ¬a = 0\n⊢ C a.leadingCoeff * normalize a = a",
"case neg\nR : Type u\ninst✝¹ : Field R\ninst✝ : DecidableEq R\na : R[X]\nha : ¬a = 0\n⊢ a ≠ 0"
] | prod_normalizedFactors_eq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.FieldDivision | {
"line": 726,
"column": 45
} | {
"line": 726,
"column": 79
} | {
"line": 726,
"column": 79
} | [
{
"pp": "R : Type u\ninst✝ : Field R\np₁ p₂ q : R[X]\nh : q ∣ p₁ - p₂\nhq : q ≠ 0\n⊢ (q * C q.leadingCoeff⁻¹).Monic",
"ppTerm": "?m.63",
"assigned": true,
"usedConstants": [
"Polynomial.C",
"GroupWithZero.toMonoidWithZero",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.t... | [] | by simp [Polynomial.Monic.def, hq] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Polynomial.UniqueFactorization | {
"line": 64,
"column": 8
} | {
"line": 64,
"column": 97
} | {
"line": 65,
"column": 8
} | [
{
"pp": "case neg\nR : Type u_1\ninst✝² : CommSemiring R\ninst✝¹ : NoZeroDivisors R\ninst✝ : WfDvdMonoid R\nf a : R[X]\nane0 : a ≠ 0\nc : R[X]\nnot_unit_c : ¬IsUnit c\nhac : ¬a * c = 0\ncne0 : c ≠ 0\nhdeg : ¬c.natDegree = 0\n⊢ ↑a.degree < ↑(a.degree + ↑c.natDegree)",
"ppTerm": "?neg✝",
"assigned": true,... | [
"case neg\nR : Type u_1\ninst✝² : CommSemiring R\ninst✝¹ : NoZeroDivisors R\ninst✝ : WfDvdMonoid R\nf a : R[X]\nane0 : a ≠ 0\nc : R[X]\nnot_unit_c : ¬IsUnit c\nhac : ¬a * c = 0\ncne0 : c ≠ 0\nhdeg : ¬c.natDegree = 0\n⊢ a.natDegree < a.natDegree + c.natDegree"
] | rw [WithTop.coe_lt_coe, Polynomial.degree_eq_natDegree ane0, ← Nat.cast_add, Nat.cast_lt] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Polynomial.UniqueFactorization | {
"line": 74,
"column": 38
} | {
"line": 76,
"column": 38
} | {
"line": 78,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝³ : CommSemiring R\ninst✝² : NoZeroDivisors R\ninst✝¹ : WfDvdMonoid R\nf : R[X]\ninst✝ : Nontrivial R\nhf : 0 < f.natDegree\n⊢ 0 < f.degree",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"WithBot.instPreorder",
"Eq.mpr",
"Nat.instMulZeroClass"... | [] | by
contrapose! hf
exact natDegree_le_of_degree_le hf | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Polynomial.Content | {
"line": 428,
"column": 4
} | {
"line": 428,
"column": 19
} | {
"line": 429,
"column": 4
} | [
{
"pp": "case mpr\nR : Type u_1\ninst✝¹ : CommRing R\ninst✝ : NormalizedGCDMonoid R\np q : R[X]\nhq : q ≠ 0\n⊢ p.content ∣ q.content ∧ p.primPart ∣ q.primPart → p ∣ q",
"ppTerm": "?mpr",
"assigned": true,
"usedConstants": [
"Dvd.dvd",
"CommRing.toNonUnitalCommRing",
"CommSemiring.t... | [
"case mpr\nR : Type u_1\ninst✝¹ : CommRing R\ninst✝ : NormalizedGCDMonoid R\np q : R[X]\nhq : q ≠ 0\nh₁ : p.content ∣ q.content\nh₂ : p.primPart ∣ q.primPart\n⊢ p ∣ q"
] | rintro ⟨h₁, h₂⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Algebra.Azumaya.Defs | {
"line": 47,
"column": 6
} | {
"line": 47,
"column": 90
} | {
"line": 48,
"column": 6
} | [
{
"pp": "R : Type u_1\nA : Type u_2\ninst✝² : CommSemiring R\ninst✝¹ : Semiring A\ninst✝ : Algebra R A\nthis : Module (A ⊗[R] Aᵐᵒᵖ) A := Algebra.module\nr : R\nab : A ⊗[R] Aᵐᵒᵖ\na : A\n⊢ (r • ab) • a = r • ab • a",
"ppTerm": "?m.76",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAdd... | [
"R : Type u_1\nA : Type u_2\ninst✝² : CommSemiring R\ninst✝¹ : Semiring A\ninst✝ : Algebra R A\nthis : Module (A ⊗[R] Aᵐᵒᵖ) A := Algebra.module\nr : R\nab : A ⊗[R] Aᵐᵒᵖ\na : A\n⊢ (Algebra.moduleAux (r • ab)) a = r • (Algebra.moduleAux ab) a"
] | change TensorProduct.Algebra.moduleAux _ _ = _ • TensorProduct.Algebra.moduleAux _ _ | Lean.Elab.Tactic.evalChange | Lean.Parser.Tactic.change |
Mathlib.RingTheory.Algebraic.Basic | {
"line": 100,
"column": 81
} | {
"line": 101,
"column": 87
} | {
"line": 103,
"column": 0
} | [
{
"pp": "R : Type u\nA : Type v\ninst✝² : CommRing R\ninst✝¹ : Ring A\ninst✝ : Algebra R A\nx : A\n⊢ IsAlgebraic R x ↔ ¬Function.Injective ⇑(aeval x)",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"_private.Mathlib.RingTheory.Algebraic.Basic.0.i... | [] | by
simp only [IsAlgebraic, injective_iff_map_eq_zero, not_forall, and_comm, exists_prop] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Algebraic.Basic | {
"line": 150,
"column": 2
} | {
"line": 151,
"column": 43
} | {
"line": 153,
"column": 0
} | [
{
"pp": "R : Type u\nA : Type v\ninst✝³ : CommRing R\ninst✝² : Ring A\ninst✝¹ : Algebra R A\ninst✝ : Nontrivial R\nn : ℤ\n⊢ IsAlgebraic R ↑n",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Int.cast",
"Eq.mpr",
"RingHom.instRingHomClass",
"Algebra.algebraMap",
... | [] | rw [← map_intCast (algebraMap R A)]
exact isAlgebraic_algebraMap (Int.cast n) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Algebraic.Basic | {
"line": 150,
"column": 2
} | {
"line": 151,
"column": 43
} | {
"line": 153,
"column": 0
} | [
{
"pp": "R : Type u\nA : Type v\ninst✝³ : CommRing R\ninst✝² : Ring A\ninst✝¹ : Algebra R A\ninst✝ : Nontrivial R\nn : ℤ\n⊢ IsAlgebraic R ↑n",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Int.cast",
"Eq.mpr",
"RingHom.instRingHomClass",
"Algebra.algebraMap",
... | [] | rw [← map_intCast (algebraMap R A)]
exact isAlgebraic_algebraMap (Int.cast n) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Algebraic.Basic | {
"line": 223,
"column": 2
} | {
"line": 223,
"column": 25
} | {
"line": 224,
"column": 2
} | [
{
"pp": "R : Type u\nS : Type u_1\nA : Type v\ninst✝¹⁰ : CommRing R\ninst✝⁹ : CommRing S\ninst✝⁸ : Ring A\ninst✝⁷ : Algebra R A\nB : Type u_2\ninst✝⁶ : Ring B\ninst✝⁵ : Algebra S B\nFRS : Type u_3\nFAB : Type u_4\ninst✝⁴ : FunLike FRS R S\ninst✝³ : RingHomClass FRS R S\ninst✝² : FunLike FAB A B\ninst✝¹ : RingHo... | [
"R : Type u\nS : Type u_1\nA : Type v\ninst✝¹⁰ : CommRing R\ninst✝⁹ : CommRing S\ninst✝⁸ : Ring A\ninst✝⁷ : Algebra R A\nB : Type u_2\ninst✝⁶ : Ring B\ninst✝⁵ : Algebra S B\nFRS : Type u_3\nFAB : Type u_4\ninst✝⁴ : FunLike FRS R S\ninst✝³ : RingHomClass FRS R S\ninst✝² : FunLike FAB A B\ninst✝¹ : RingHomClass FAB A... | obtain ⟨a, rfl⟩ := hg b | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {
"line": 615,
"column": 2
} | {
"line": 617,
"column": 28
} | {
"line": 618,
"column": 2
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\na b c : Associates α\nha : a ≠ 0\nhb : b ≠ 0\nhab : ∀ (d : Associates α), d ∣ a → d ∣ b → ¬Prime d\nk : ℕ\nh : a * b = c ^ k\na✝ : Nontrivial α\nhk0 : k = 0\n⊢ ∃ d, a = d ^ k",
"ppTerm": "?pos✝",
"assign... | [
"case neg\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\na b c : Associates α\nha : a ≠ 0\nhb : b ≠ 0\nhab : ∀ (d : Associates α), d ∣ a → d ∣ b → ¬Prime d\nk : ℕ\nh : a * b = c ^ k\na✝ : Nontrivial α\nhk0 : ¬k = 0\n⊢ ∃ d, a = d ^ k"
] | · use 1
rw [hk0, pow_zero] at h ⊢
apply (mul_eq_one.1 h).1 | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.LinearAlgebra.TensorProduct.Finiteness | {
"line": 94,
"column": 61
} | {
"line": 98,
"column": 61
} | {
"line": 100,
"column": 0
} | [
{
"pp": "R : Type u_1\nM : Type u_2\nN : Type u_3\ninst✝⁴ : CommSemiring R\ninst✝³ : AddCommMonoid M\ninst✝² : AddCommMonoid N\ninst✝¹ : Module R M\ninst✝ : Module R N\nx : M ⊗[R] N\n⊢ ∃ S, x = ∑ i ∈ S, i.1 ⊗ₜ[R] i.2",
"ppTerm": "?m.45",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLik... | [] | by
obtain ⟨S, h⟩ := exists_finsupp_left x
use S.graph
rw [h, Finsupp.sum]
apply Finset.sum_nbij' (fun m ↦ ⟨m, S m⟩) Prod.fst <;> simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.LinearAlgebra.TensorProduct.RightExactness | {
"line": 461,
"column": 4
} | {
"line": 461,
"column": 50
} | {
"line": 462,
"column": 4
} | [
{
"pp": "case a\nR : Type u_1\ninst✝⁴ : CommSemiring R\nA : Type u_2\nB : Type u_3\ninst✝³ : Semiring A\ninst✝² : Semiring B\ninst✝¹ : Algebra R A\ninst✝ : Algebra R B\nI : Ideal A\nx : A ⊗[R] B\nhx : x ∈ ↑(Submodule.restrictScalars R (Submodule.span (A ⊗[R] B) (⇑includeLeft '' ↑I)))\n⊢ ∃ y, (LinearMap.rTensor ... | [
"case a.refine_1\nR : Type u_1\ninst✝⁴ : CommSemiring R\nA : Type u_2\nB : Type u_3\ninst✝³ : Semiring A\ninst✝² : Semiring B\ninst✝¹ : Algebra R A\ninst✝ : Algebra R B\nI : Ideal A\nx : A ⊗[R] B\nhx : x ∈ ↑(Submodule.restrictScalars R (Submodule.span (A ⊗[R] B) (⇑includeLeft '' ↑I)))\n⊢ ∀ x ∈ ⇑includeLeft '' ↑I, ∃... | refine Submodule.span_induction ?_ ?_ ?_ ?_ hx | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Algebra.Colimit.DirectLimit | {
"line": 258,
"column": 4
} | {
"line": 258,
"column": 56
} | {
"line": 259,
"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... | [] | simp_rw [map₂_def, map_def, div_eq_mul_inv, mul_def] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Algebra.Colimit.DirectLimit | {
"line": 258,
"column": 4
} | {
"line": 258,
"column": 56
} | {
"line": 259,
"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... | [] | simp_rw [map₂_def, map_def, div_eq_mul_inv, mul_def] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Colimit.DirectLimit | {
"line": 258,
"column": 4
} | {
"line": 258,
"column": 56
} | {
"line": 259,
"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... | [] | simp_rw [map₂_def, map_def, div_eq_mul_inv, mul_def] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Colimit.DirectLimit | {
"line": 343,
"column": 4
} | {
"line": 343,
"column": 56
} | {
"line": 344,
"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... | [] | simp_rw [map₂_def, map_def, div_eq_mul_inv, mul_def] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Algebra.Colimit.DirectLimit | {
"line": 343,
"column": 4
} | {
"line": 343,
"column": 56
} | {
"line": 344,
"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... | [] | simp_rw [map₂_def, map_def, div_eq_mul_inv, mul_def] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Colimit.DirectLimit | {
"line": 343,
"column": 4
} | {
"line": 343,
"column": 56
} | {
"line": 344,
"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... | [] | simp_rw [map₂_def, map_def, div_eq_mul_inv, mul_def] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.TensorProduct.RightExactness | {
"line": 525,
"column": 4
} | {
"line": 525,
"column": 50
} | {
"line": 526,
"column": 4
} | [
{
"pp": "case a\nR : Type u_1\ninst✝⁴ : CommSemiring R\nA : Type u_2\nB : Type u_3\ninst✝³ : Semiring A\ninst✝² : Semiring B\ninst✝¹ : Algebra R A\ninst✝ : Algebra R B\nI : Ideal B\nx : A ⊗[R] B\nhx : x ∈ ↑(Submodule.restrictScalars R (Submodule.span (A ⊗[R] B) (⇑includeRight '' ↑I)))\n⊢ ∃ y, (LinearMap.lTensor... | [
"case a.refine_1\nR : Type u_1\ninst✝⁴ : CommSemiring R\nA : Type u_2\nB : Type u_3\ninst✝³ : Semiring A\ninst✝² : Semiring B\ninst✝¹ : Algebra R A\ninst✝ : Algebra R B\nI : Ideal B\nx : A ⊗[R] B\nhx : x ∈ ↑(Submodule.restrictScalars R (Submodule.span (A ⊗[R] B) (⇑includeRight '' ↑I)))\n⊢ ∀ x ∈ ⇑includeRight '' ↑I,... | refine Submodule.span_induction ?_ ?_ ?_ ?_ hx | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Algebra.Colimit.DirectLimit | {
"line": 846,
"column": 24
} | {
"line": 846,
"column": 40
} | {
"line": 846,
"column": 40
} | [
{
"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... | [
"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 fun x1 x2 x3 ... | algebraMap_def i | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.BigOperators.Expect | {
"line": 364,
"column": 2
} | {
"line": 364,
"column": 64
} | {
"line": 365,
"column": 2
} | [
{
"pp": "ι : Type u_1\nK : Type u_3\ninst✝⁴ : Semifield K\ninst✝³ : CharZero K\ninst✝² : Fintype ι\ninst✝¹ : Nonempty ι\ninst✝ : DecidableEq ι\nf : ι → K\ni : ι\n⊢ (↑(Fintype.card ι))⁻¹ • (↑(Fintype.card ι) * f i) = f i",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Eq.mpr",
... | [
"case ha\nι : Type u_1\nK : Type u_3\ninst✝⁴ : Semifield K\ninst✝³ : CharZero K\ninst✝² : Fintype ι\ninst✝¹ : Nonempty ι\ninst✝ : DecidableEq ι\nf : ι → K\ni : ι\n⊢ ↑(Fintype.card ι) ≠ 0"
] | rw [← @NNRat.cast_natCast K, ← NNRat.smul_def, inv_smul_smul₀] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.BigOperators.Group.Finset.Gaps | {
"line": 46,
"column": 2
} | {
"line": 48,
"column": 52
} | {
"line": 49,
"column": 2
} | [
{
"pp": "case i_inj\nα : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder α\ninst✝ : CommGroup β\nF : Finset (α × α)\nk : ℕ\nh : #F = k\na b : α\nf : α → α → β\np : Fin (k + 1) → α × α := ⋯\n⊢ ∀ a₁ ∈ range k, ∀ a₂ ∈ range k, ((p ↑a₁).2, (p ↑a₁.succ).1) = ((p ↑a₂).2, (p ↑a₂.succ).1) → a₁ = a₂",
"ppTerm": "?i_inj... | [
"case i_surj\nα : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder α\ninst✝ : CommGroup β\nF : Finset (α × α)\nk : ℕ\nh : #F = k\na b : α\nf : α → α → β\np : Fin (k + 1) → α × α := ⋯\n⊢ ∀ b ∈ F, ∃ a, ∃ (_ : a ∈ range k), ((p ↑a).2, (p ↑a.succ).1) = b",
"case h\nα : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder α\ninst... | · intro i hi j hj hij
rw [mem_range] at hi hj
apply F.intervalGapsWithin_injOn h a b <;> grind | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.Interval.Finset.Gaps | {
"line": 172,
"column": 40
} | {
"line": 172,
"column": 64
} | {
"line": 172,
"column": 64
} | [
{
"pp": "α : Type u_1\ninst✝ : LinearOrder α\nF : Finset (α × α)\nk : ℕ\nh : #F = k\nj✝ : ℕ\na b : α\nhab : a ≤ b\nhFab : ∀ ⦃z : α × α⦄, z ∈ F → a ≤ z.1 ∧ z.1 ≤ z.2 ∧ z.2 ≤ b\nhF : (↑F).PairwiseDisjoint fun z ↦ Icc z.1 z.2\nj : ℕ\nhj : j < k + 1\nhj₁ : ¬j = 0\nhk : k - 1 + 1 = k\nhj₂ : ¬j = k\nhj₃ : ⟨j - 1, ⋯⟩ ... | [] | simp [le_iff_val_le_val] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Order.Interval.Finset.Gaps | {
"line": 172,
"column": 40
} | {
"line": 172,
"column": 64
} | {
"line": 172,
"column": 64
} | [
{
"pp": "α : Type u_1\ninst✝ : LinearOrder α\nF : Finset (α × α)\nk : ℕ\nh : #F = k\nj✝ : ℕ\na b : α\nhab : a ≤ b\nhFab : ∀ ⦃z : α × α⦄, z ∈ F → a ≤ z.1 ∧ z.1 ≤ z.2 ∧ z.2 ≤ b\nhF : (↑F).PairwiseDisjoint fun z ↦ Icc z.1 z.2\nj : ℕ\nhj : j < k + 1\nhj₁ : ¬j = 0\nhk : k - 1 + 1 = k\nhj₂ : ¬j = k\nhj₃ : ⟨j - 1, ⋯⟩ ... | [] | simp [le_iff_val_le_val] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Interval.Finset.Gaps | {
"line": 172,
"column": 40
} | {
"line": 172,
"column": 64
} | {
"line": 172,
"column": 64
} | [
{
"pp": "α : Type u_1\ninst✝ : LinearOrder α\nF : Finset (α × α)\nk : ℕ\nh : #F = k\nj✝ : ℕ\na b : α\nhab : a ≤ b\nhFab : ∀ ⦃z : α × α⦄, z ∈ F → a ≤ z.1 ∧ z.1 ≤ z.2 ∧ z.2 ≤ b\nhF : (↑F).PairwiseDisjoint fun z ↦ Icc z.1 z.2\nj : ℕ\nhj : j < k + 1\nhj₁ : ¬j = 0\nhk : k - 1 + 1 = k\nhj₂ : ¬j = k\nhj₃ : ⟨j - 1, ⋯⟩ ... | [] | simp [le_iff_val_le_val] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Functor.FullyFaithful | {
"line": 296,
"column": 56
} | {
"line": 296,
"column": 86
} | {
"line": 296,
"column": 86
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nF F' : C ⥤ D\ninst✝ : F.Full\nα : F ≅ F'\nX Y : C\nf : F'.obj X ⟶ F'.obj Y\n⊢ F'.map (F.preimage ((α.app X).hom ≫ f ≫ (α.app Y).inv)) = f",
"ppTerm": "?m.64",
"assigned": true,
"usedConstants": [
"Ca... | [] | simp [← NatIso.naturality_1 α] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Functor.FullyFaithful | {
"line": 296,
"column": 56
} | {
"line": 296,
"column": 86
} | {
"line": 296,
"column": 86
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nF F' : C ⥤ D\ninst✝ : F.Full\nα : F ≅ F'\nX Y : C\nf : F'.obj X ⟶ F'.obj Y\n⊢ F'.map (F.preimage ((α.app X).hom ≫ f ≫ (α.app Y).inv)) = f",
"ppTerm": "?m.64",
"assigned": true,
"usedConstants": [
"Ca... | [] | simp [← NatIso.naturality_1 α] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Functor.FullyFaithful | {
"line": 296,
"column": 56
} | {
"line": 296,
"column": 86
} | {
"line": 296,
"column": 86
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nF F' : C ⥤ D\ninst✝ : F.Full\nα : F ≅ F'\nX Y : C\nf : F'.obj X ⟶ F'.obj Y\n⊢ F'.map (F.preimage ((α.app X).hom ≫ f ≫ (α.app Y).inv)) = f",
"ppTerm": "?m.64",
"assigned": true,
"usedConstants": [
"Ca... | [] | simp [← NatIso.naturality_1 α] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.IsTensorProduct | {
"line": 731,
"column": 2
} | {
"line": 740,
"column": 33
} | {
"line": 742,
"column": 0
} | [
{
"pp": "R : 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✝³ : IsScalarTower R R... | [] | ext x
refine H.1.inductionOn x _ ?_ ?_ ?_ ?_
· simp only [map_zero]
· exact AlgHom.congr_fun h₁
· intro s s' e
rw [Algebra.smul_def, map_mul, map_mul, e]
congr 1
exact (AlgHom.congr_fun h₂ s :)
· intro s₁ s₂ e₁ e₂
rw [map_add, map_add, e₁, e₂] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.