module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 365
values | kind stringclasses 368
values |
|---|---|---|---|---|---|---|
Mathlib.NumberTheory.ArithmeticFunction.Misc | {
"line": 321,
"column": 2
} | {
"line": 321,
"column": 76
} | [
{
"pp": "n : ℕ\n⊢ Ω n = n.factorization.sum fun x k ↦ k",
"usedConstants": [
"Finsupp.instFunLike",
"Nat.instMulZeroClass",
"ArithmeticFunction.instFunLikeNat",
"congrArg",
"Finset",
"_private.Mathlib.NumberTheory.ArithmeticFunction.Misc.0.ArithmeticFunction.cardFactors_e... | simp [cardFactors_apply, ← List.sum_toFinset_count_eq_length, Finsupp.sum] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.ArithmeticFunction.Misc | {
"line": 321,
"column": 2
} | {
"line": 321,
"column": 76
} | [
{
"pp": "n : ℕ\n⊢ Ω n = n.factorization.sum fun x k ↦ k",
"usedConstants": [
"Finsupp.instFunLike",
"Nat.instMulZeroClass",
"ArithmeticFunction.instFunLikeNat",
"congrArg",
"Finset",
"_private.Mathlib.NumberTheory.ArithmeticFunction.Misc.0.ArithmeticFunction.cardFactors_e... | simp [cardFactors_apply, ← List.sum_toFinset_count_eq_length, Finsupp.sum] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.ArithmeticFunction.Misc | {
"line": 378,
"column": 4
} | {
"line": 378,
"column": 57
} | [
{
"pp": "case cons\nι : Type u_2\nf : ι → ℕ\na : ι\ns : Finset ι\nha : a ∉ s\nih : (↑s).Pairwise (Coprime on f) → ω (∏ i ∈ s, f i) = ∑ i ∈ s, ω (f i)\nh : (↑(cons a s ha)).Pairwise (Coprime on f)\n⊢ ω (∏ i ∈ cons a s ha, f i) = ∑ i ∈ cons a s ha, ω (f i)",
"usedConstants": [
"Eq.mpr",
"Nat.instM... | rw [prod_cons, sum_cons, cardDistinctFactors_mul, ih] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.NumberTheory.ArithmeticFunction.Defs | {
"line": 265,
"column": 6
} | {
"line": 265,
"column": 16
} | [
{
"pp": "case h\nR : Type u_1\nM : Type u_2\ninst✝² : Semiring R\ninst✝¹ : AddCommMonoid M\ninst✝ : Module R M\nb : ArithmeticFunction M\nx : ℕ\n⊢ (1 • b) x = b x",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHSMul",
"Nat.divisorsAntidiagonal",
... | smul_apply | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.ArithmeticFunction.Defs | {
"line": 535,
"column": 27
} | {
"line": 535,
"column": 88
} | [
{
"pp": "R : Type u_1\ninst✝ : CommSemiring R\nf g : ArithmeticFunction R\nhf : f.IsMultiplicative\nhg : g.IsMultiplicative\na1 a2 b1 b2 : ℕ\nha : ((a1, a2), b1, b2).1.1 * ((a1, a2), b1, b2).1.2 ≠ 0\ncop : (((a1, a2), b1, b2).1.1 * ((a1, a2), b1, b2).1.2).Coprime (((a1, a2), b1, b2).2.1 * ((a1, a2), b1, b2).2.2... | cop.coprime_mul_left.coprime_mul_right_right.symm.gcd_eq_one, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.ArithmeticFunction.Defs | {
"line": 538,
"column": 10
} | {
"line": 538,
"column": 71
} | [
{
"pp": "R : Type u_1\ninst✝ : CommSemiring R\nf g : ArithmeticFunction R\nhf : f.IsMultiplicative\nhg : g.IsMultiplicative\na1 a2 b1 b2 : ℕ\nha : ((a1, a2), b1, b2).1.1 * ((a1, a2), b1, b2).1.2 ≠ 0\nhb : ((a1, a2), b1, b2).2.1 * ((a1, a2), b1, b2).2.2 ≠ 0\nc1 c2 d1 d2 : ℕ\ncop : (((c1, c2), d1, d2).1.1 * ((c1,... | cop.coprime_mul_left.coprime_mul_right_right.symm.gcd_eq_one, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.CompleteField | {
"line": 66,
"column": 4
} | {
"line": 66,
"column": 21
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\ninst✝² : Field α\ninst✝¹ : ConditionallyCompleteLinearOrder α\ninst✝ : IsStrictOrderedRing α\n⊢ ∀ (x : α), ∃ n, x < ↑n",
"usedConstants": [
"Preorder.toLT",
"Classical.byContradiction",
"PartialOrder.toPreorder",
"AddGr... | by_contra! ⟨x, h⟩ | Mathlib.Tactic.ByContra._aux_Mathlib_Tactic_ByContra___macroRules_Mathlib_Tactic_ByContra_byContra!_1 | Mathlib.Tactic.ByContra.byContra! |
Mathlib.Algebra.Order.CompleteField | {
"line": 248,
"column": 6
} | {
"line": 248,
"column": 16
} | [
{
"pp": "case inr\nα : Type u_2\nβ : Type u_3\ninst✝⁶ : Field α\ninst✝⁵ : LinearOrder α\ninst✝⁴ : IsStrictOrderedRing α\ninst✝³ : Field β\ninst✝² : ConditionallyCompleteLinearOrder β\ninst✝¹ : IsStrictOrderedRing β\ninst✝ : Archimedean α\na : α\nha : 0 < a\nb : β\nhba : b < inducedMap α β a * inducedMap α β a\n... | ← cast_pow | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.NumberTheory.ArithmeticFunction.Defs | {
"line": 641,
"column": 2
} | {
"line": 645,
"column": 42
} | [
{
"pp": "R : Type u_1\ninst✝ : CommSemiring R\nι : Type u_2\nf : ι → ArithmeticFunction R\ns : Finset ι\nhf : ∀ i ∈ s, (f i).IsMultiplicative\n⊢ (∏ i ∈ s, f i).IsMultiplicative",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
"Finset.cons_induction",
"Monoid.toMulOne... | induction s using Finset.cons_induction
case empty => simp
case cons a s ha ih =>
rw [Finset.prod_cons]
exact (hf a (by grind)).mul (by grind) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.ArithmeticFunction.Defs | {
"line": 641,
"column": 2
} | {
"line": 645,
"column": 42
} | [
{
"pp": "R : Type u_1\ninst✝ : CommSemiring R\nι : Type u_2\nf : ι → ArithmeticFunction R\ns : Finset ι\nhf : ∀ i ∈ s, (f i).IsMultiplicative\n⊢ (∏ i ∈ s, f i).IsMultiplicative",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
"Finset.cons_induction",
"Monoid.toMulOne... | induction s using Finset.cons_induction
case empty => simp
case cons a s ha ih =>
rw [Finset.prod_cons]
exact (hf a (by grind)).mul (by grind) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Archimedean.Class | {
"line": 532,
"column": 2
} | {
"line": 532,
"column": 38
} | [
{
"pp": "M : Type u_1\ninst✝⁵ : CommGroup M\ninst✝⁴ : LinearOrder M\ninst✝³ : IsOrderedMonoid M\na b : M\nN : Type u_2\ninst✝² : CommGroup N\ninst✝¹ : LinearOrder N\ninst✝ : IsOrderedMonoid N\nf : M →*o N\nh : mk a = mk b\n⊢ mk (f a) = mk (f b)",
"usedConstants": [
"Eq.mpr",
"OrderMonoidHom",
... | rw [← orderHom_mk, ← orderHom_mk, h] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Archimedean.Class | {
"line": 532,
"column": 2
} | {
"line": 532,
"column": 38
} | [
{
"pp": "M : Type u_1\ninst✝⁵ : CommGroup M\ninst✝⁴ : LinearOrder M\ninst✝³ : IsOrderedMonoid M\na b : M\nN : Type u_2\ninst✝² : CommGroup N\ninst✝¹ : LinearOrder N\ninst✝ : IsOrderedMonoid N\nf : M →*o N\nh : mk a = mk b\n⊢ mk (f a) = mk (f b)",
"usedConstants": [
"Eq.mpr",
"OrderMonoidHom",
... | rw [← orderHom_mk, ← orderHom_mk, h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Archimedean.Class | {
"line": 532,
"column": 2
} | {
"line": 532,
"column": 38
} | [
{
"pp": "M : Type u_1\ninst✝⁵ : CommGroup M\ninst✝⁴ : LinearOrder M\ninst✝³ : IsOrderedMonoid M\na b : M\nN : Type u_2\ninst✝² : CommGroup N\ninst✝¹ : LinearOrder N\ninst✝ : IsOrderedMonoid N\nf : M →*o N\nh : mk a = mk b\n⊢ mk (f a) = mk (f b)",
"usedConstants": [
"Eq.mpr",
"OrderMonoidHom",
... | rw [← orderHom_mk, ← orderHom_mk, h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.GroupWithZero.Bounds | {
"line": 27,
"column": 2
} | {
"line": 27,
"column": 59
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝³ : Nonempty α\ninst✝² : Preorder β\ninst✝¹ : Zero β\ninst✝ : Preorder γ\nf : α → β\ng : β → γ\nhf : BddAbove (range f)\nhf0 : 0 ≤ f\nhg : MonotoneOn g {x | 0 ≤ x}\n⊢ BddAbove (g '' range f)",
"usedConstants": [
"MonotoneOn.map_bddAbove",
"... | apply hg.map_bddAbove (by rintro x ⟨a, rfl⟩; exact hf0 a) | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.Order.Group.Ideal | {
"line": 44,
"column": 4
} | {
"line": 44,
"column": 27
} | [
{
"pp": "case h.mp\nM : Type u_1\ninst✝³ : CommMonoid M\ninst✝² : PartialOrder M\ninst✝¹ : WellQuasiOrderedLE M\ninst✝ : CanonicallyOrderedMul M\nI : SemigroupIdeal M\nhpwo : {x | x ∈ I}.IsPWO\nx : M\nhx : x ∈ I\nz : M\nhz : ∃ c, x = c * z\nhz' : Minimal (fun x ↦ x ∈ {x | x ∈ I}) z\n⊢ ∃ y z, Minimal (fun x ↦ x ... | rcases hz with ⟨y, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Algebra.Order.Group.Int.Sum | {
"line": 50,
"column": 12
} | {
"line": 50,
"column": 14
} | [
{
"pp": "case h.e'_4.refine_1\ns : Finset ℤ\nc : ℤ\nhs : ∀ x ∈ s, x ≤ c\nx : ℕ\n⊢ x ∈ range #s → (fun x ↦ c - ↑x) x ∈ Ioc (c - ↑(#s)) c",
"usedConstants": [
"Finset",
"Membership.mem",
"Int",
"Finset.range",
"Finset.instSetLike",
"Nat",
"Finset.card",
"SetLike... | mx | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Algebra.Order.Group.Int.Sum | {
"line": 51,
"column": 12
} | {
"line": 51,
"column": 14
} | [
{
"pp": "case h.e'_4.refine_2\ns : Finset ℤ\nc : ℤ\nhs : ∀ x ∈ s, x ≤ c\nx : ℕ\n⊢ x ∈ ↑(range #s) → ∀ ⦃x₂ : ℕ⦄, x₂ ∈ ↑(range #s) → (fun x ↦ c - ↑x) x = (fun x ↦ c - ↑x) x₂ → x = x₂",
"usedConstants": [
"Finset",
"Membership.mem",
"Int",
"Finset.range",
"SetLike.coe",
"Fin... | mx | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Algebra.Order.Group.Int.Sum | {
"line": 52,
"column": 12
} | {
"line": 52,
"column": 14
} | [
{
"pp": "case h.e'_4.refine_3\ns : Finset ℤ\nc : ℤ\nhs : ∀ x ∈ s, x ≤ c\nx : ℤ\n⊢ x ∈ ↑(Ioc (c - ↑(#s)) c) → x ∈ (fun x ↦ c - ↑x) '' ↑(range #s)",
"usedConstants": [
"Finset",
"PartialOrder.toPreorder",
"HSub.hSub",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Int"... | mx | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Algebra.Order.Group.Int.Sum | {
"line": 76,
"column": 12
} | {
"line": 76,
"column": 14
} | [
{
"pp": "case h.e'_3.refine_1\ns : Finset ℤ\nc : ℤ\nhs : ∀ x ∈ s, c ≤ x\nx : ℕ\n⊢ x ∈ range #s → (fun x ↦ c + ↑x) x ∈ Ico c (c + ↑(#s))",
"usedConstants": [
"Finset",
"Membership.mem",
"Int",
"Finset.range",
"Finset.instSetLike",
"Nat",
"Finset.card",
"SetLike... | mx | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Algebra.Order.Group.Int.Sum | {
"line": 77,
"column": 12
} | {
"line": 77,
"column": 14
} | [
{
"pp": "case h.e'_3.refine_2\ns : Finset ℤ\nc : ℤ\nhs : ∀ x ∈ s, c ≤ x\nx : ℕ\n⊢ x ∈ ↑(range #s) → ∀ ⦃x₂ : ℕ⦄, x₂ ∈ ↑(range #s) → (fun x ↦ c + ↑x) x = (fun x ↦ c + ↑x) x₂ → x = x₂",
"usedConstants": [
"Finset",
"Membership.mem",
"Int",
"Finset.range",
"SetLike.coe",
"Fin... | mx | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Algebra.Order.Group.Int.Sum | {
"line": 78,
"column": 12
} | {
"line": 78,
"column": 14
} | [
{
"pp": "case h.e'_3.refine_3\ns : Finset ℤ\nc : ℤ\nhs : ∀ x ∈ s, c ≤ x\nx : ℤ\n⊢ x ∈ ↑(Ico c (c + ↑(#s))) → x ∈ (fun x ↦ c + ↑x) '' ↑(range #s)",
"usedConstants": [
"Finset",
"PartialOrder.toPreorder",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Finset.Ico",
"Int... | mx | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Algebra.Order.Interval.Set.SuccPred | {
"line": 53,
"column": 2
} | {
"line": 53,
"column": 70
} | [
{
"pp": "α : Type u_2\ninst✝³ : LinearOrder α\ninst✝² : One α\ninst✝¹ : Add α\ninst✝ : SuccAddOrder α\na : α\nha : ¬IsMax a\nb : α\n⊢ Icc (a + 1) b = Ioc a b",
"usedConstants": [
"Set.Ioc",
"Order.succ",
"Order.succ_eq_add_one",
"congrArg",
"PartialOrder.toPreorder",
"Sem... | simpa [succ_eq_add_one] using Icc_succ_left_eq_Ioc_of_not_isMax ha b | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Order.Interval.Set.SuccPred | {
"line": 53,
"column": 2
} | {
"line": 53,
"column": 70
} | [
{
"pp": "α : Type u_2\ninst✝³ : LinearOrder α\ninst✝² : One α\ninst✝¹ : Add α\ninst✝ : SuccAddOrder α\na : α\nha : ¬IsMax a\nb : α\n⊢ Icc (a + 1) b = Ioc a b",
"usedConstants": [
"Set.Ioc",
"Order.succ",
"Order.succ_eq_add_one",
"congrArg",
"PartialOrder.toPreorder",
"Sem... | simpa [succ_eq_add_one] using Icc_succ_left_eq_Ioc_of_not_isMax ha b | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Interval.Set.SuccPred | {
"line": 53,
"column": 2
} | {
"line": 53,
"column": 70
} | [
{
"pp": "α : Type u_2\ninst✝³ : LinearOrder α\ninst✝² : One α\ninst✝¹ : Add α\ninst✝ : SuccAddOrder α\na : α\nha : ¬IsMax a\nb : α\n⊢ Icc (a + 1) b = Ioc a b",
"usedConstants": [
"Set.Ioc",
"Order.succ",
"Order.succ_eq_add_one",
"congrArg",
"PartialOrder.toPreorder",
"Sem... | simpa [succ_eq_add_one] using Icc_succ_left_eq_Ioc_of_not_isMax ha b | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Interval.Basic | {
"line": 488,
"column": 6
} | {
"line": 488,
"column": 50
} | [
{
"pp": "ι : Type u_1\nα✝ : Type u_2\ninst✝⁵ : CommGroup α✝\ninst✝⁴ : PartialOrder α✝\ninst✝³ : IsOrderedMonoid α✝\ns✝ t✝ : NonemptyInterval α✝\nα : Type u\ninst✝² : AddCommGroup α\ninst✝¹ : PartialOrder α\ninst✝ : IsOrderedAddMonoid α\ns t : NonemptyInterval α\n⊢ s - t = s + -t",
"usedConstants": [
"... | refine NonemptyInterval.ext (Prod.ext ?_ ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Algebra.Order.Interval.Basic | {
"line": 492,
"column": 6
} | {
"line": 492,
"column": 50
} | [
{
"pp": "ι : Type u_1\nα✝ : Type u_2\ninst✝⁵ : CommGroup α✝\ninst✝⁴ : PartialOrder α✝\ninst✝³ : IsOrderedMonoid α✝\ns✝ t✝ : NonemptyInterval α✝\nα : Type u\ninst✝² : AddCommGroup α\ninst✝¹ : PartialOrder α\ninst✝ : IsOrderedAddMonoid α\ns t : NonemptyInterval α\n⊢ -(s + t) = -t + -s",
"usedConstants": [
... | refine NonemptyInterval.ext (Prod.ext ?_ ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Algebra.Order.Interval.Basic | {
"line": 495,
"column": 6
} | {
"line": 495,
"column": 74
} | [
{
"pp": "ι : Type u_1\nα✝ : Type u_2\ninst✝⁵ : CommGroup α✝\ninst✝⁴ : PartialOrder α✝\ninst✝³ : IsOrderedMonoid α✝\ns✝ t✝ : NonemptyInterval α✝\nα : Type u\ninst✝² : AddCommGroup α\ninst✝¹ : PartialOrder α\ninst✝ : IsOrderedAddMonoid α\ns t : NonemptyInterval α\nh : s + t = 0\n⊢ -s = t",
"usedConstants": [
... | obtain ⟨a, b, rfl, rfl, hab⟩ := NonemptyInterval.add_eq_zero_iff.1 h | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Algebra.Order.Interval.Basic | {
"line": 504,
"column": 6
} | {
"line": 504,
"column": 50
} | [
{
"pp": "ι : Type u_1\nα : Type u_2\ninst✝² : CommGroup α\ninst✝¹ : PartialOrder α\ninst✝ : IsOrderedMonoid α\ns✝ t✝ s t : NonemptyInterval α\n⊢ s / t = s * t⁻¹",
"usedConstants": [
"Semigroup.toMul",
"instDivNonemptyInterval",
"instHDiv",
"HMul.hMul",
"PartialOrder.toPreorder"... | refine NonemptyInterval.ext (Prod.ext ?_ ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Algebra.Order.Interval.Basic | {
"line": 508,
"column": 6
} | {
"line": 508,
"column": 50
} | [
{
"pp": "ι : Type u_1\nα : Type u_2\ninst✝² : CommGroup α\ninst✝¹ : PartialOrder α\ninst✝ : IsOrderedMonoid α\ns✝ t✝ s t : NonemptyInterval α\n⊢ (s * t)⁻¹ = t⁻¹ * s⁻¹",
"usedConstants": [
"Semigroup.toMul",
"HMul.hMul",
"PartialOrder.toPreorder",
"Preorder.toLE",
"NonemptyInter... | refine NonemptyInterval.ext (Prod.ext ?_ ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Algebra.Order.Module.Archimedean | {
"line": 38,
"column": 51
} | {
"line": 38,
"column": 62
} | [
{
"pp": "M : Type u_1\ninst✝⁸ : AddCommGroup M\ninst✝⁷ : LinearOrder M\ninst✝⁶ : IsOrderedAddMonoid M\nK : Type u_2\ninst✝⁵ : Ring K\ninst✝⁴ : LinearOrder K\ninst✝³ : IsOrderedRing K\ninst✝² : Archimedean K\ninst✝¹ : Module K M\ninst✝ : PosSMulMono K M\na : M\nk : K\nh : k ≠ 0\nthis : Nontrivial K\nm : ℕ\nhm : ... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.HahnSeries.Basic | {
"line": 403,
"column": 36
} | {
"line": 404,
"column": 51
} | [
{
"pp": "Γ : Type u_1\nR : Type u_3\ninst✝² : PartialOrder Γ\ninst✝¹ : Zero R\ninst✝ : Zero Γ\nx : R⟦Γ⟧\nhx : x ≠ 0\n⊢ 0 < x.orderTop ↔ 0 < x.order",
"usedConstants": [
"HahnSeries.support",
"Iff.mpr",
"HahnSeries.order",
"Preorder.toLT",
"WithTop.instPreorder",
"congrArg... | by
simp_all [orderTop_of_ne_zero hx, order_of_ne hx] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.HahnSeries.Addition | {
"line": 464,
"column": 4
} | {
"line": 464,
"column": 19
} | [
{
"pp": "case coeff.h\nΓ : Type u_1\nΓ' : Type u_2\nR : Type u_3\nS : Type u_4\nU : Type u_5\nV✝ : Type u_6\nα : Type u_7\ninst✝³ : PartialOrder Γ\nV : Type u_8\ninst✝² : Monoid R\ninst✝¹ : AddMonoid V\ninst✝ : DistribMulAction R V\nx✝³ x✝² : R\nx✝¹ : V⟦Γ⟧\nx✝ : Γ\n⊢ ((x✝³ * x✝²) • x✝¹).coeff x✝ = (x✝³ • x✝² • ... | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder | {
"line": 81,
"column": 6
} | {
"line": 81,
"column": 49
} | [
{
"pp": "case inr\nM : Type u_1\nG : Type u_2\ninst✝⁷ : AddCancelCommMonoid M\ninst✝⁶ : LinearOrder M\ninst✝⁵ : IsOrderedAddMonoid M\ninst✝⁴ : LocallyFiniteOrder M\ninst✝³ : AddCommGroup G\ninst✝² : LinearOrder G\ninst✝¹ : IsOrderedAddMonoid G\ninst✝ : LocallyFiniteOrder G\na b : G\nthis :\n ∀ (a b : G),\n ... | convert this b a (le_of_not_ge hab) using 1 | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___elabRules_Mathlib_Tactic_convert_1 | Mathlib.Tactic.convert |
Mathlib.RingTheory.HahnSeries.Lex | {
"line": 407,
"column": 4
} | {
"line": 407,
"column": 87
} | [
{
"pp": "Γ : Type u_1\nR : Type u_2\ninst✝³ : LinearOrder Γ\ninst✝² : PartialOrder R\nΓ' : Type u_3\ninst✝¹ : LinearOrder Γ'\nf : Γ ↪o Γ'\ninst✝ : Zero R\na b : Lex R⟦Γ⟧\n⊢ (∃ i,\n (∀ j < i,\n (ofLex ({ toFun := fun a ↦ toLex (embDomain f (ofLex a)), inj' := ⋯ } a)).coeff j =\n (o... | simp only [Function.Embedding.coeFn_mk, ofLex_toLex, EmbeddingLike.apply_eq_iff_eq] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.RingTheory.Valuation.ValuationSubring | {
"line": 530,
"column": 6
} | {
"line": 530,
"column": 63
} | [
{
"pp": "case neg.inr\nK : Type u\ninst✝ : Field K\nA B : ValuationSubring K\nh : A.unitGroup ≤ B.unitGroup\nx : K\nh_1 : ¬x = 0\nh_2 : ¬1 + x = 0\nhx : A.valuation x = 1\nthis : Units.mk0 x h_1 ∈ B.unitGroup\n⊢ x ∈ B",
"usedConstants": [
"Units.val",
"ValuationSubring.unitGroup",
"MulEqui... | exact SetLike.coe_mem (B.unitGroupMulEquiv ⟨_, this⟩ : B) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.Valuation.ValuationSubring | {
"line": 532,
"column": 4
} | {
"line": 532,
"column": 33
} | [
{
"pp": "case mpr\nK : Type u\ninst✝ : Field K\nA B : ValuationSubring K\nh : A ≤ B\nx : Kˣ\nhx : A.valuation ↑x = 1\n⊢ x ∈ B.unitGroup",
"usedConstants": [
"Units.val",
"GroupWithZero.toMonoidWithZero",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"InvOneClass... | apply_fun A.mapOfLE B h at hx | Mathlib.Tactic._aux_Mathlib_Tactic_ApplyFun___elabRules_Mathlib_Tactic_applyFun_1 | Mathlib.Tactic.applyFun |
Mathlib.Algebra.Polynomial.CoeffList | {
"line": 109,
"column": 4
} | {
"line": 110,
"column": 54
} | [
{
"pp": "case succ\nR : Type u_1\ninst✝ : Semiring R\nx : R\nhx : x ≠ 0\nn : ℕ\nh : ¬(monomial n) x = 0\nk : ℕ\nh₁✝¹ : k + 1 < ((monomial n) x).coeffList.length\nh₁✝ : k + 1 < (x :: List.replicate n 0).length\nh₁ : k + 1 < n + 1\nthis : ((monomial n) x).natDegree.succ = n + 1\n⊢ ((monomial n) x).coeffList.get ⟨... | simpa [coeffList, withBotSucc_degree_eq_natDegree_add_one h]
using Polynomial.coeff_monomial_of_ne _ (by lia) | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | {
"line": 89,
"column": 18
} | {
"line": 89,
"column": 26
} | [
{
"pp": "case succ\nR : Type u_1\ninst✝ : Semiring R\np : R[X]\nm : ℕ\nhp : p.IsMonicOfDegree m\nn : ℕ\nih : (p ^ n).IsMonicOfDegree (m * n)\n⊢ (p ^ n * p).IsMonicOfDegree (m * (n + 1))",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"HMul.hMul",
"Monoid.toMulOneClass",
... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.DenomsClearable | {
"line": 61,
"column": 47
} | {
"line": 61,
"column": 55
} | [
{
"pp": "R : Type u_1\nK : Type u_2\ninst✝¹ : Semiring R\ninst✝ : CommSemiring K\ni : R →+* K\na b : R\nN : ℕ\nf g : R[X]\nx✝¹ : DenomsClearable a b N f i\nx✝ : DenomsClearable a b N g i\nDf : R\nbf : K\nbfu : bf * i b = 1\nHf : i Df = i b ^ N * eval (i a * bf) (Polynomial.map i f)\nDg : R\nbg : K\nbgu : bg * i... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | {
"line": 241,
"column": 4
} | {
"line": 243,
"column": 81
} | [] | _ ≤ max (C a * X).natDegree (C b).natDegree := natDegree_sub_le ..
_ = (C a * X).natDegree := by simp
_ < 2 := natDegree_C_mul_le .. |>.trans natDegree_X_le |>.trans_lt one_lt_two | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcSteps |
Mathlib.Algebra.Polynomial.Mirror | {
"line": 60,
"column": 2
} | {
"line": 65,
"column": 84
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\np : R[X]\n⊢ p.mirror.natDegree = p.natDegree",
"usedConstants": [
"Nontrivial",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Nat.instOrderedSub",
"Polynomial.natDegr... | by_cases hp : p = 0
· rw [hp, mirror_zero]
nontriviality R
rw [mirror, natDegree_mul', reverse_natDegree, natDegree_X_pow,
tsub_add_cancel_of_le p.natTrailingDegree_le_natDegree]
rwa [leadingCoeff_X_pow, mul_one, reverse_leadingCoeff, Ne, trailingCoeff_eq_zero] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Mirror | {
"line": 60,
"column": 2
} | {
"line": 65,
"column": 84
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\np : R[X]\n⊢ p.mirror.natDegree = p.natDegree",
"usedConstants": [
"Nontrivial",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Nat.instOrderedSub",
"Polynomial.natDegr... | by_cases hp : p = 0
· rw [hp, mirror_zero]
nontriviality R
rw [mirror, natDegree_mul', reverse_natDegree, natDegree_X_pow,
tsub_add_cancel_of_le p.natTrailingDegree_le_natDegree]
rwa [leadingCoeff_X_pow, mul_one, reverse_leadingCoeff, Ne, trailingCoeff_eq_zero] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Mirror | {
"line": 170,
"column": 12
} | {
"line": 170,
"column": 21
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝¹ : Semiring R\np q : R[X]\ninst✝ : NoZeroDivisors R\nhp : ¬p = 0\nhq : q = 0\n⊢ (p * 0).mirror = p.mirror * mirror 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"NonUnitalNonAssocSemiring.toMulZeroClass",
... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.StandardPart | {
"line": 348,
"column": 54
} | {
"line": 348,
"column": 65
} | [
{
"pp": "K : Type u_1\ninst✝² : LinearOrder K\ninst✝¹ : Field K\ninst✝ : IsOrderedRing K\nx y : K\nhx : 0 ≤ mk x\nhy : 0 ≤ mk y\n⊢ stdPart x + stdPart (-y) = stdPart x + -stdPart y",
"usedConstants": [
"Eq.mpr",
"NegZeroClass.toNeg",
"Real",
"AddGroupWithOne.toAddGroup",
"congr... | stdPart_neg | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.StandardPart | {
"line": 352,
"column": 47
} | {
"line": 352,
"column": 58
} | [
{
"pp": "K : Type u_1\ninst✝² : LinearOrder K\ninst✝¹ : Field K\ninst✝ : IsOrderedRing K\nx y : K\nhx : 0 < mk x\n⊢ stdPart (-y) = -stdPart y",
"usedConstants": [
"Eq.mpr",
"NegZeroClass.toNeg",
"Real",
"AddGroupWithOne.toAddGroup",
"congrArg",
"Field.toDivisionRing",
... | stdPart_neg | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.StandardPart | {
"line": 426,
"column": 97
} | {
"line": 428,
"column": 34
} | [
{
"pp": "K : Type u_1\ninst✝² : LinearOrder K\ninst✝¹ : Field K\ninst✝ : IsOrderedRing K\nx : K\nf : ℝ →+*o K\nr : ℝ\nhx : 0 ≤ mk x\nh : stdPart x < r\n⊢ x < f r",
"usedConstants": [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"neg_lt_neg_iff._simp_1",
"AddGroup.toSubtractionMon... | by
rw [← neg_lt_neg_iff, ← map_neg]
apply lt_of_lt_stdPart <;> simpa | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.PartialFractions | {
"line": 113,
"column": 63
} | {
"line": 113,
"column": 76
} | [
{
"pp": "case succ.refine_2\nR : Type u_1\ninst✝¹ : CommRing R\ninst✝ : Nontrivial R\nf g : R[X]\nhg : g.Monic\nn : ℕ\nq : R[X]\nr : Fin n → R[X]\nhr : ∀ (i : Fin n), (r i).degree < g.degree\nhf : f = q * g ^ n + ∑ i, r i * g ^ ↑i\n⊢ q * g ^ n + ∑ i, r i * g ^ ↑i =\n q %ₘ g * g ^ ↑(Fin.last n) + (q /ₘ g * g ... | Fin.val_last, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.PartialFractions | {
"line": 128,
"column": 22
} | {
"line": 128,
"column": 36
} | [
{
"pp": "R : Type u_1\ninst✝ : CommRing R\ng : R[X]\nhg : g.Monic\nq₁ q₂ : R[X]\nr₁ r₂ : Fin 0 → R[X]\nhr₁ : ∀ (i : Fin 0), (r₁ i).degree < g.degree\nhr₂ : ∀ (i : Fin 0), (r₂ i).degree < g.degree\nhf : q₁ * g ^ 0 + ∑ i, r₁ i * g ^ ↑i = q₂ * g ^ 0 + ∑ i, r₂ i * g ^ ↑i\n⊢ q₁ = q₂",
"usedConstants": [
"M... | simpa using hf | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Polynomial.PartialFractions | {
"line": 128,
"column": 22
} | {
"line": 128,
"column": 36
} | [
{
"pp": "R : Type u_1\ninst✝ : CommRing R\ng : R[X]\nhg : g.Monic\nq₁ q₂ : R[X]\nr₁ r₂ : Fin 0 → R[X]\nhr₁ : ∀ (i : Fin 0), (r₁ i).degree < g.degree\nhr₂ : ∀ (i : Fin 0), (r₂ i).degree < g.degree\nhf : q₁ * g ^ 0 + ∑ i, r₁ i * g ^ ↑i = q₂ * g ^ 0 + ∑ i, r₂ i * g ^ ↑i\n⊢ q₁ = q₂",
"usedConstants": [
"M... | simpa using hf | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.PartialFractions | {
"line": 128,
"column": 22
} | {
"line": 128,
"column": 36
} | [
{
"pp": "R : Type u_1\ninst✝ : CommRing R\ng : R[X]\nhg : g.Monic\nq₁ q₂ : R[X]\nr₁ r₂ : Fin 0 → R[X]\nhr₁ : ∀ (i : Fin 0), (r₁ i).degree < g.degree\nhr₂ : ∀ (i : Fin 0), (r₂ i).degree < g.degree\nhf : q₁ * g ^ 0 + ∑ i, r₁ i * g ^ ↑i = q₂ * g ^ 0 + ∑ i, r₂ i * g ^ ↑i\n⊢ q₁ = q₂",
"usedConstants": [
"M... | simpa using hf | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Smeval | {
"line": 204,
"column": 78
} | {
"line": 204,
"column": 87
} | [
{
"pp": "case monomial.succ\nR : Type u_1\ninst✝⁴ : Semiring R\np : R[X]\nS : Type u_2\ninst✝³ : NonAssocSemiring S\ninst✝² : Module R S\ninst✝¹ : Pow S ℕ\ninst✝ : NatPowAssoc S\na : R\nn : ℕ\n⊢ a • (0 ^ n * 0) = 0 • 1",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.PartialFractions | {
"line": 207,
"column": 13
} | {
"line": 207,
"column": 27
} | [
{
"pp": "case empty\nR : Type u_1\ninst✝¹ : CommRing R\nι : Type u_2\ninst✝ : DecidableEq ι\ng : ι → R[X]\nq₁ q₂ : R[X]\nr₁ r₂ : ι → R[X]\nhg : ∀ i ∈ ∅, (g i).Monic\nhgg : (↑∅).Pairwise fun i j ↦ IsCoprime (g i) (g j)\nhr₁ : ∀ i ∈ ∅, (r₁ i).degree < (g i).degree\nhr₂ : ∀ i ∈ ∅, (r₂ i).degree < (g i).degree\nhf ... | simpa using hf | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Polynomial.PartialFractions | {
"line": 207,
"column": 13
} | {
"line": 207,
"column": 27
} | [
{
"pp": "case empty\nR : Type u_1\ninst✝¹ : CommRing R\nι : Type u_2\ninst✝ : DecidableEq ι\ng : ι → R[X]\nq₁ q₂ : R[X]\nr₁ r₂ : ι → R[X]\nhg : ∀ i ∈ ∅, (g i).Monic\nhgg : (↑∅).Pairwise fun i j ↦ IsCoprime (g i) (g j)\nhr₁ : ∀ i ∈ ∅, (r₁ i).degree < (g i).degree\nhr₂ : ∀ i ∈ ∅, (r₂ i).degree < (g i).degree\nhf ... | simpa using hf | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.PartialFractions | {
"line": 207,
"column": 13
} | {
"line": 207,
"column": 27
} | [
{
"pp": "case empty\nR : Type u_1\ninst✝¹ : CommRing R\nι : Type u_2\ninst✝ : DecidableEq ι\ng : ι → R[X]\nq₁ q₂ : R[X]\nr₁ r₂ : ι → R[X]\nhg : ∀ i ∈ ∅, (g i).Monic\nhgg : (↑∅).Pairwise fun i j ↦ IsCoprime (g i) (g j)\nhr₁ : ∀ i ∈ ∅, (r₁ i).degree < (g i).degree\nhr₂ : ∀ i ∈ ∅, (r₂ i).degree < (g i).degree\nhf ... | simpa using hf | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.SumIteratedDerivative | {
"line": 236,
"column": 14
} | {
"line": 236,
"column": 23
} | [
{
"pp": "case hq\nR : Type u_1\ninst✝⁴ : CommSemiring R\nA : Type u_3\ninst✝³ : CommRing A\ninst✝² : Algebra R A\ninst✝¹ : Nontrivial A\ninst✝ : NoZeroDivisors A\np : R[X]\nq : ℕ\nhq : 0 < q\ninj_amap : Function.Injective ⇑(algebraMap R A)\np0 : p ≠ 0\nc : ℕ → R[X] := fun k ↦ if hk : q ≤ k then ⋯.choose else 0\... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.PartialFractions | {
"line": 227,
"column": 37
} | {
"line": 227,
"column": 45
} | [
{
"pp": "case cons\nR : Type u_1\ninst✝¹ : CommRing R\nι : Type u_2\ninst✝ : DecidableEq ι\ng : ι → R[X]\nq₁ q₂ : R[X]\nr₁ r₂ : ι → R[X]\ni : ι\ns : Finset ι\nhi : i ∉ s\nih :\n (∀ i ∈ s, (g i).Monic) →\n ((↑s).Pairwise fun i j ↦ IsCoprime (g i) (g j)) →\n (∀ i ∈ s, (r₁ i).degree < (g i).degree) →\n ... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.UnitTrinomial | {
"line": 175,
"column": 11
} | {
"line": 175,
"column": 20
} | [
{
"pp": "k m n : ℕ\nhkm : k < m\nhmn : m < n\nx y z : ℤ\nhp : #{k, m, n} = 3 ∧ ∀ k_1 ∈ {k, m, n}, IsUnit ((C x * X ^ k + C y * X ^ m + C z * X ^ n).coeff k_1)\nhx : IsUnit (x + y * 0 + z * 0)\nhy : IsUnit (x * 0 + y + z * 0)\nhz : IsUnit (x * 0 + y * 0 + z)\n⊢ (C x * X ^ k + C y * X ^ m + C z * X ^ n).IsUnitTri... | mul_zero, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Polynomial.UnitTrinomial | {
"line": 188,
"column": 62
} | {
"line": 188,
"column": 95
} | [
{
"pp": "case refine_1\nk m n : ℕ\nhkm : k < m\nhmn : m < n\nu v w : ℤˣ\n⊢ (trinomial k m n ↑u ↑v ↑w).coeff k ^ 2 +\n ((trinomial k m n ↑u ↑v ↑w).coeff m ^ 2 + (trinomial k m n ↑u ↑v ↑w).coeff n ^ 2) =\n 3",
"usedConstants": [
"Units.val",
"Eq.mpr",
"Polynomial.trinomial",
"c... | trinomial_leading_coeff' hkm hmn, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.UnitTrinomial | {
"line": 212,
"column": 60
} | {
"line": 212,
"column": 68
} | [
{
"pp": "p : ℤ[X]\nk m n : ℕ\nhkm : k < m\nhmn : m < n\nu v w : ℤˣ\nhp : p = trinomial k m n ↑u ↑v ↑w\nkey : n - m + k < n\n⊢ C ↑v * ((monomial (m + n)) ↑u + (monomial (n - m + k + n)) ↑w) =\n {\n toFinsupp :=\n Finsupp.filter (fun x ↦ x ∈ Set.Ioo (k + n) (n + n))\n ((monomial k) ↑u * ((... | mul_add, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Polynomial.PartialFractions | {
"line": 251,
"column": 18
} | {
"line": 251,
"column": 27
} | [
{
"pp": "case cons\nR : Type u_1\ninst✝¹ : CommRing R\nι : Type u_2\ninst✝ : DecidableEq ι\ng : ι → R[X]\nq₁ q₂ : R[X]\nr₁ r₂ : ι → R[X]\ni : ι\ns : Finset ι\nhi : i ∉ s\nih :\n (∀ i ∈ s, (g i).Monic) →\n ((↑s).Pairwise fun i j ↦ IsCoprime (g i) (g j)) →\n (∀ i ∈ s, (r₁ i).degree < (g i).degree) →\n ... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.QuadraticAlgebra.Defs | {
"line": 275,
"column": 31
} | {
"line": 275,
"column": 46
} | [
{
"pp": "case re\nR : Type u_1\nS : Type u_2\nT : Type u_3\na b r : R\nx y : QuadraticAlgebra R a b\ninst✝¹ : Monoid S\ninst✝ : MulAction S R\nx✝² x✝¹ : S\nx✝ : QuadraticAlgebra R a b\n⊢ ((x✝² * x✝¹) • x✝).re = (x✝² • x✝¹ • x✝).re",
"usedConstants": [
"QuadraticAlgebra.re",
"QuadraticAlgebra.ins... | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.QuadraticAlgebra.Defs | {
"line": 275,
"column": 31
} | {
"line": 275,
"column": 46
} | [
{
"pp": "case im\nR : Type u_1\nS : Type u_2\nT : Type u_3\na b r : R\nx y : QuadraticAlgebra R a b\ninst✝¹ : Monoid S\ninst✝ : MulAction S R\nx✝² x✝¹ : S\nx✝ : QuadraticAlgebra R a b\n⊢ ((x✝² * x✝¹) • x✝).im = (x✝² • x✝¹ • x✝).im",
"usedConstants": [
"QuadraticAlgebra.instSMul",
"Semigroup.toMu... | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.QuadraticAlgebra.Basic | {
"line": 93,
"column": 31
} | {
"line": 95,
"column": 32
} | [
{
"pp": "R : Type u_1\na b : R\ninst✝² : CommSemiring R\nA : Type u_2\ninst✝¹ : Ring A\ninst✝ : Algebra R A\nf g : QuadraticAlgebra R a b →ₐ[R] A\nh : f ω = g ω\n⊢ f = g",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"QuadraticAlgebra.instSMul",
"instHSMul",
"Semirin... | by
ext ⟨x, y⟩
simp [mk_eq_add_smul_omega, h] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.QuaternionBasis | {
"line": 127,
"column": 20
} | {
"line": 127,
"column": 28
} | [
{
"pp": "R : Type u_1\nA : Type u_2\ninst✝² : CommRing R\ninst✝¹ : Ring A\ninst✝ : Algebra R A\nc₁ c₂ c₃ : R\nq : Basis A c₁ c₂ c₃\nx y : ℍ[R,c₁,c₂,c₃]\n⊢ (x * y).re • 1 + (x * y).imI • q.i + (x * y).imJ • q.j + (x * y).imK • q.k =\n x.re • 1 * (y.re • 1 + y.imI • q.i + y.imJ • q.j + y.imK • q.k) +\n ... | mul_add, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Ring.WithZero | {
"line": 25,
"column": 4
} | {
"line": 25,
"column": 45
} | [
{
"pp": "case coe.coe.coe\nα : Type u_1\ninst✝² : Mul α\ninst✝¹ : Add α\ninst✝ : LeftDistribClass α\na✝² a✝¹ a✝ : α\n⊢ ↑a✝² * (↑a✝¹ + ↑a✝) = ↑a✝² * ↑a✝¹ + ↑a✝² * ↑a✝",
"usedConstants": [
"HMul.hMul",
"Option.some",
"congr_arg",
"instHAdd",
"HAdd.hAdd",
"left_distrib",
... | exact congr_arg some (left_distrib _ _ _) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Polynomial.RuleOfSigns | {
"line": 247,
"column": 4
} | {
"line": 247,
"column": 61
} | [
{
"pp": "case h.left\nR : Type u_1\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\nP : R[X]\nη : R\nh₁ : 0 < P.leadingCoeff\nh₃ : P ≠ 0\nh₄ : P.eraseLead.natDegree + 1 = P.natDegree\nh₅ : X - C η ≠ 0\nh₆ : P.eraseLead ≠ 0\nd : ℕ\nhd : P.natDegree = 0 + d + 1\nh₂ : P.eraseLead.leadingCoe... | have := leadingCoeff_monic_mul (q := P) (monic_X_sub_C η) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.SkewMonoidAlgebra.Lift | {
"line": 124,
"column": 2
} | {
"line": 124,
"column": 27
} | [
{
"pp": "k : Type u_1\nG : Type u_2\nH : Type u_3\ninst✝ : AddCommMonoid k\nf : G ≃ H\nl : SkewMonoidAlgebra k G\n⊢ equivMapDomain f l = (mapDomain ⇑f) l",
"usedConstants": [
"SkewMonoidAlgebra.mapDomain",
"SkewMonoidAlgebra.equivMapDomain",
"Equiv.instEquivLike",
"AddMonoid.toAddZer... | apply toFinsupp_injective | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.SkewMonoidAlgebra.Lift | {
"line": 142,
"column": 2
} | {
"line": 142,
"column": 27
} | [
{
"pp": "k : Type u_1\nG : Type u_2\nH : Type u_3\ninst✝ : AddCommMonoid k\nf : G ≃ H\na : G\nb : k\n⊢ equivMapDomain f (single a b) = single (f a) b",
"usedConstants": [
"SkewMonoidAlgebra.equivMapDomain",
"Equiv.instEquivLike",
"Equiv",
"SkewMonoidAlgebra.toFinsupp_injective",
... | apply toFinsupp_injective | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.SkewMonoidAlgebra.Single | {
"line": 60,
"column": 2
} | {
"line": 60,
"column": 27
} | [
{
"pp": "M : Type u_4\nα : Type u_5\ninst✝ : AddCommMonoid M\na : α\nf : SkewMonoidAlgebra M α\n⊢ single a (f.coeff a) + (erase a) f = f",
"usedConstants": [
"AddMonoid.toAddZeroClass",
"SkewMonoidAlgebra.instAddMonoid",
"AddZeroClass.toAddZero",
"SkewMonoidAlgebra.toFinsupp_injectiv... | apply toFinsupp_injective | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.SkewMonoidAlgebra.Single | {
"line": 71,
"column": 4
} | {
"line": 78,
"column": 47
} | [
{
"pp": "M : Type u_4\nα : Type u_5\ninst✝ : AddCommMonoid M\np : SkewMonoidAlgebra M α → Prop\nf✝ : SkewMonoidAlgebra M α\nh0 : p 0\nha : ∀ (a : α) (b : M) (f : SkewMonoidAlgebra M α), a ∉ f.support → b ≠ 0 → p f → p (single a b + f)\ns✝ : Finset α\na : α\ns : Finset α\nhas : a ∉ s\nih : ∀ (f : SkewMonoidAlgeb... | suffices p (single a (f.coeff a) + f.erase a) by rwa [single_add_erase] at this
classical
apply ha
· rw [support_erase, Finset.mem_erase]
exact fun H ↦ H.1 rfl
· simp only [← mem_support_iff, hf, Finset.mem_cons_self]
· apply ih
rw [support_erase, hf, Finset.erase_cons] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.SkewMonoidAlgebra.Single | {
"line": 71,
"column": 4
} | {
"line": 78,
"column": 47
} | [
{
"pp": "M : Type u_4\nα : Type u_5\ninst✝ : AddCommMonoid M\np : SkewMonoidAlgebra M α → Prop\nf✝ : SkewMonoidAlgebra M α\nh0 : p 0\nha : ∀ (a : α) (b : M) (f : SkewMonoidAlgebra M α), a ∉ f.support → b ≠ 0 → p f → p (single a b + f)\ns✝ : Finset α\na : α\ns : Finset α\nhas : a ∉ s\nih : ∀ (f : SkewMonoidAlgeb... | suffices p (single a (f.coeff a) + f.erase a) by rwa [single_add_erase] at this
classical
apply ha
· rw [support_erase, Finset.mem_erase]
exact fun H ↦ H.1 rfl
· simp only [← mem_support_iff, hf, Finset.mem_cons_self]
· apply ih
rw [support_erase, hf, Finset.erase_cons] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.SkewMonoidAlgebra.Single | {
"line": 96,
"column": 2
} | {
"line": 96,
"column": 27
} | [
{
"pp": "M : Type u_4\nα : Type u_5\ninst✝ : AddCommMonoid M\na : α\nf : α →₀ M\n⊢ { toFinsupp := f }.update a ({ toFinsupp := f }.coeff a) = { toFinsupp := f }",
"usedConstants": [
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"SkewMonoidAlgebra.ofFinsupp",
"SkewMonoidAlgebr... | apply toFinsupp_injective | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.Polynomial.RuleOfSigns | {
"line": 388,
"column": 2
} | {
"line": 388,
"column": 68
} | [
{
"pp": "case succ\nR : Type u_1\ninst✝² : CommRing R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\nn✝ : ℕ\nih : ∀ (P : R[X]), Multiset.countP (fun x ↦ 0 < x) P.roots = n✝ → n✝ ≤ P.signVariations\nP : R[X]\nh : Multiset.countP (fun x ↦ 0 < x) P.roots = n✝ + 1\nhp : P ≠ 0\nη : R\nη_root : η ∈ P.roots\n... | obtain ⟨Q, rfl⟩ := dvd_iff_isRoot.mpr (isRoot_of_mem_roots η_root) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Algebra.Star.UnitaryStarAlgAut | {
"line": 40,
"column": 26
} | {
"line": 40,
"column": 41
} | [
{
"pp": "case h\nS : Type u_1\nR : Type u_2\ninst✝⁴ : Semiring R\ninst✝³ : StarMul R\ninst✝² : SMul S R\ninst✝¹ : IsScalarTower S R R\ninst✝ : SMulCommClass S R R\ng h : ↥(unitary R)\na✝ : R\n⊢ (let __RingEquiv := MulSemiringAction.toRingEquiv (ConjAct Rˣ) R (ConjAct.toConjAct (toUnits (g * h)));\n { toRin... | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.SkewMonoidAlgebra.Basic | {
"line": 387,
"column": 2
} | {
"line": 387,
"column": 27
} | [
{
"pp": "k : Type u_1\nG : Type u_2\ninst✝¹ : AddCommMonoid k\nk' : Type u_3\nG' : Type u_4\ninst✝ : AddCommMonoid k'\nf : G →₀ k\ng : G → k → G' →₀ k'\n⊢ { toFinsupp := f.sum g } = { toFinsupp := f }.sum fun x1 x2 ↦ { toFinsupp := g x1 x2 }",
"usedConstants": [
"AddMonoid.toAddZeroClass",
"Fins... | apply toFinsupp_injective | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.SkewMonoidAlgebra.Basic | {
"line": 390,
"column": 2
} | {
"line": 390,
"column": 27
} | [
{
"pp": "k : Type u_1\nG : Type u_2\ninst✝ : AddCommMonoid k\nf : SkewMonoidAlgebra k G\n⊢ f.sum single = f",
"usedConstants": [
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"SkewMonoidAlgebra.toFinsupp_injective",
"AddZero.toZero",
"SkewMonoidAlgebra",
"AddCommM... | apply toFinsupp_injective | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.Symmetrized | {
"line": 255,
"column": 41
} | {
"line": 255,
"column": 50
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Semiring α\ninst✝ : Invertible 2\nx✝ : αˢʸᵐ\n⊢ sym (⅟2 * (0 + unsym x✝ * 0)) = 0",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Equiv.instEquivLike",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"SymAlg.s... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Symmetrized | {
"line": 256,
"column": 8
} | {
"line": 256,
"column": 17
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Semiring α\ninst✝ : Invertible 2\nx✝ : αˢʸᵐ\n⊢ sym (⅟2 * 0) = 0",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Equiv.instEquivLike",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"SymAlg.sym",
"AddMo... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Symmetrized | {
"line": 258,
"column": 41
} | {
"line": 258,
"column": 50
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Semiring α\ninst✝ : Invertible 2\nx✝ : αˢʸᵐ\n⊢ sym (⅟2 * (unsym x✝ * 0 + 0)) = 0",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Equiv.instEquivLike",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"SymAlg.s... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Symmetrized | {
"line": 259,
"column": 8
} | {
"line": 259,
"column": 17
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Semiring α\ninst✝ : Invertible 2\nx✝ : αˢʸᵐ\n⊢ sym (⅟2 * 0) = 0",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Equiv.instEquivLike",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"SymAlg.sym",
"AddMo... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Tropical.BigOperators | {
"line": 120,
"column": 42
} | {
"line": 120,
"column": 67
} | [
{
"pp": "R : Type u_1\nS : Type u_2\ninst✝¹ : ConditionallyCompleteLinearOrder R\ninst✝ : Fintype S\nf : S → Tropical (WithTop R)\n⊢ untrop (∑ i, f i) = sInf ((fun i ↦ untrop (f i)) '' ↑univ)",
"usedConstants": [
"WithTop.instInfSet",
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Finset.uni... | untrop_sum_eq_sInf_image, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Star.LinearMap | {
"line": 301,
"column": 2
} | {
"line": 301,
"column": 18
} | [
{
"pp": "case h\nR : Type u_4\nV : Type u_5\ninst✝⁵ : CommRing R\ninst✝⁴ : InvolutiveStar R\ninst✝³ : AddCommGroup V\ninst✝² : StarAddMonoid V\ninst✝¹ : Module R V\ninst✝ : StarModule R V\nf : WithConv (End R V)\nx : R\n⊢ IsUnit (star (toConv (x • 1 - (star f).ofConv))).ofConv ↔ IsUnit (star x • 1 - f.ofConv)",... | simp [one_eq_id] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Topology.Sheaves.SheafOfFunctions | {
"line": 60,
"column": 4
} | {
"line": 60,
"column": 77
} | [
{
"pp": "X : TopCat\nT : ↑X → Type u_1\nι : Type u_2\nU : ι → Opens ↑X\nsf : (i : ι) → ToType ((X.presheafToTypes T).obj (Opposite.op (U i)))\nhsf : (X.presheafToTypes T).IsCompatible U sf\nindex : ↥(iSup U) → ι\nindex_spec : ∀ (x : ↥(iSup U)), ↑x ∈ U (index x)\n⊢ ∃! s, (X.presheafToTypes T).IsGluing U sf s",
... | let s : ∀ x : ↑(iSup U), T x := fun x => sf (index x) ⟨x.1, index_spec x⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.AlgebraicGeometry.Spec | {
"line": 402,
"column": 4
} | {
"line": 404,
"column": 31
} | [
{
"pp": "case h₃\nR S : CommRingCat\nf : R ⟶ S\np : PrimeSpectrum ↑R\ninst✝ : Algebra ↑R ↑S\nx : ↑S\nhx : (toPushforwardStalkAlgHom R S p) x = 0\n⊢ ∃ m, m • x = 0",
"usedConstants": [
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"Lattice.toSemilatticeSup",
"Semiring.toModul... | rw [toPushforwardStalkAlgHom_apply,
← (toPushforwardStalk (CommRingCat.ofHom (algebraMap ↑R ↑S)) p).hom.map_zero,
toPushforwardStalk] at hx | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.AlgebraicGeometry.OpenImmersion | {
"line": 861,
"column": 5
} | {
"line": 864,
"column": 46
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nX✝ Y✝ : Scheme\nf✝ : X✝ ⟶ Y✝\nH : IsOpenImmersion f✝\nP X Y Z : Scheme\nfst : P ⟶ X\nsnd : P ⟶ Y\nf : X ⟶ Z\ng : Y ⟶ Z\nh : IsPullback fst snd f g\ninst✝ : IsOpenImmersion g\np : ↥P\nx : ↥X\nhx : fst p = x\nthis : IsOpenImmersion fst\n⊢ (Z.presheaf.stalkCongr ⋯ ≪... | by
subst hx
simp [← Scheme.Hom.stalkMap_comp, ← Scheme.Hom.stalkMap_comp,
Scheme.Hom.stalkMap_congr_hom _ _ h.w] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.AlgebraicGeometry.Restrict | {
"line": 557,
"column": 47
} | {
"line": 557,
"column": 70
} | [
{
"pp": "case refine_1\nX : Scheme\nU V W : X.Opens\nhU : U ≤ W\nhV : V ≤ W\n⊢ V.ι ''ᵁ (Opens.map ((X.homOfLE hV).base ≫ W.ι.base)).obj U = U ⊓ V",
"usedConstants": [
"AlgebraicGeometry.Scheme.Hom.opensFunctor",
"Eq.mpr",
"AlgebraicGeometry.SheafedSpace.instTopologicalSpaceCarrierCarrier",... | ← Scheme.Hom.comp_base, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Category.TopCommRingCat | {
"line": 61,
"column": 25
} | {
"line": 61,
"column": 55
} | [
{
"pp": "R : TopCommRingCat\n⊢ Continuous ⇑(RingHom.id R.α)",
"usedConstants": [
"RingHom.id._proof_3",
"Eq.mpr",
"MulOne.toOne",
"Continuous",
"RingHom.mk",
"congrArg",
"CommSemiring.toSemiring",
"OneHom.mk",
"RingHom.id._proof_4",
"RingHom",
... | by rw [RingHom.id]; continuity | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.AlgebraicGeometry.StructureSheaf | {
"line": 465,
"column": 4
} | {
"line": 467,
"column": 85
} | [
{
"pp": "R M : Type u\ninst✝² : CommRing R\ninst✝¹ : AddCommGroup M\ninst✝ : Module R M\nU : Opens ↑(PrimeSpectrum.Top R)\nhU : IsCompact ↑U\ns : (structureSheafInType R M).obj.obj (op U)\ng : ↥U → R\nhxg : ∀ (x : ↥U), ↑x ∈ basicOpen (g x)\nigU : ∀ (x : ↥U), basicOpen (g x) ≤ U\nf : ↥U → M\nH : ∀ (x : ↥U), cons... | · refine congr((structureSheafInType R M).obj.map (homOfLE ((PrimeSpectrum.basicOpen_mul (g i)
(g j)).trans_le inf_le_left)).op $(H i)).symm.trans (Subtype.ext <| funext fun a ↦ ?_)
exact LocalizedModule.mk_eq.mpr ⟨1, by simp [Submonoid.smul_def, ← smul_assoc]⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.AlgebraicGeometry.GammaSpecAdjunction | {
"line": 290,
"column": 4
} | {
"line": 290,
"column": 46
} | [
{
"pp": "X Y : LocallyRingedSpace\nf : X ⟶ Y\n⊢ X.toΓSpec ≫ (Γ.rightOp ⋙ Spec.toLocallyRingedSpace).map f = (𝟭 LocallyRingedSpace).map f ≫ Y.toΓSpec",
"usedConstants": [
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"AlgebraicGeometry.LocallyRingedSpace.Γ",
"CommRingCat",
... | apply LocallyRingedSpace.comp_ring_hom_ext | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.AlgebraicGeometry.GammaSpecAdjunction | {
"line": 317,
"column": 2
} | {
"line": 317,
"column": 44
} | [
{
"pp": "R : CommRingCat\n⊢ identityToΓSpec.app (Spec.toLocallyRingedSpace.obj (op R)) ≫\n Spec.toLocallyRingedSpace.map (SpecΓIdentity.inv.app R).op =\n 𝟙 ((𝟭 LocallyRingedSpace).obj (Spec.toLocallyRingedSpace.obj (op R)))",
"usedConstants": [
"CategoryTheory.Functor",
"Opposite",
... | apply LocallyRingedSpace.comp_ring_hom_ext | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.AlgebraicGeometry.StructureSheaf | {
"line": 1029,
"column": 2
} | {
"line": 1029,
"column": 17
} | [
{
"pp": "R M : Type u\ninst✝⁵ : CommRing R\ninst✝⁴ : AddCommGroup M\ninst✝³ : Module R M\nS : Type u\ninst✝² : CommRing S\nN : Type u\ninst✝¹ : AddCommGroup N\ninst✝ : Module S N\nσ : R →+* S\nf : M →ₛₗ[σ] N\nU : Opens ↑(PrimeSpectrum.Top R)\nV : Opens ↑(PrimeSpectrum.Top S)\nhUV : V.carrier ⊆ PrimeSpectrum.com... | refine ⟨hs, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Geometry.RingedSpace.LocallyRingedSpace.HasColimits | {
"line": 90,
"column": 70
} | {
"line": 103,
"column": 22
} | [
{
"pp": "ι : Type v\ninst✝ : Small.{u, v} ι\nF : Discrete ι ⥤ LocallyRingedSpace\ns : Cocone F\n⊢ ∀ (x : ↑(coproductCofan F).pt.toTopCat),\n IsLocalHom\n (CommRingCat.Hom.hom\n (PresheafedSpace.Hom.stalkMap (colimit.desc (F ⋙ forgetToSheafedSpace) (forgetToSheafedSpace.mapCocone s)).hom\n ... | by
intro x
obtain ⟨i, y, ⟨⟩⟩ := SheafedSpace.colimit_exists_rep (F ⋙ forgetToSheafedSpace) x
have := PresheafedSpace.stalkMap.comp
(colimit.ι (F ⋙ forgetToSheafedSpace) i).hom
(colimit.desc (F ⋙ forgetToSheafedSpace) (forgetToSheafedSpace.mapCocone s)).hom y
simp only... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.GlueData | {
"line": 467,
"column": 8
} | {
"line": 467,
"column": 54
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v, u₁} C\nC' : Type u₂\ninst✝ : Category.{v, u₂} C'\nD : GlueData' C\ni k : D.J\nhik : ¬i = k\n⊢ ((if hij : i = i then\n (pullbackSymmetry (D.f' i i) (D.f' i k)).hom ≫\n pullback.map (D.f' i k) (D.f' i i) (D.f' i k) (D.f' i i) (eqToHom ⋯) (eqToHom ⋯) (eqT... | simp [hik, Ne.symm hik, fst_eq_snd_of_mono_eq] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Geometry.RingedSpace.LocallyRingedSpace.HasColimits | {
"line": 226,
"column": 2
} | {
"line": 226,
"column": 62
} | [
{
"pp": "case map_nonunit\nX Y : LocallyRingedSpace\nf g : X ⟶ Y\nx : ↑Y.toTopCat\na :\n ↑((coequalizer (Hom.toShHom f) (Hom.toShHom g)).presheaf.stalk\n ((ConcreteCategory.hom (coequalizer.π (Hom.toShHom f) (Hom.toShHom g)).hom.base) x))\nha :\n IsUnit ((CommRingCat.Hom.hom (PresheafedSpace.Hom.stalkMap... | rcases TopCat.Presheaf.germ_exist _ _ a with ⟨U, hU, s, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.CategoryTheory.GlueData | {
"line": 467,
"column": 8
} | {
"line": 467,
"column": 54
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v, u₁} C\nC' : Type u₂\ninst✝ : Category.{v, u₂} C'\nD : GlueData' C\ni k : D.J\nhik : ¬i = k\n⊢ ((if hij : i = i then\n (pullbackSymmetry (D.f' i i) (D.f' i k)).hom ≫\n pullback.map (D.f' i k) (D.f' i i) (D.f' i k) (D.f' i i) (eqToHom ⋯) (eqToHom ⋯) (eqT... | simp [hik, Ne.symm hik, fst_eq_snd_of_mono_eq] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.GlueData | {
"line": 467,
"column": 8
} | {
"line": 467,
"column": 54
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v, u₁} C\nC' : Type u₂\ninst✝ : Category.{v, u₂} C'\nD : GlueData' C\ni k : D.J\nhik : ¬i = k\n⊢ ((if hij : i = i then\n (pullbackSymmetry (D.f' i i) (D.f' i k)).hom ≫\n pullback.map (D.f' i k) (D.f' i i) (D.f' i k) (D.f' i i) (eqToHom ⋯) (eqToHom ⋯) (eqT... | simp [hik, Ne.symm hik, fst_eq_snd_of_mono_eq] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Constructions.Over.Products | {
"line": 108,
"column": 82
} | {
"line": 113,
"column": 26
} | [
{
"pp": "J : Type w\nC : Type u\ninst✝ : Category.{v, u} C\nX Y Z : C\nf : Y ⟶ X\ng : Z ⟶ X\nc : BinaryFan (Over.mk f) (Over.mk g)\nhc : IsLimit c\ns : PullbackCone f g\nm : s.pt ⟶ (𝟭 C).obj (((Functor.const (Discrete WalkingPair)).obj c.pt).obj { as := WalkingPair.left }).left\nhm₁ : m ≫ (𝟭 C).map c.fst.left... | by
have := c.fst.w
simp only [pair_obj_left, Over.mk_left, Functor.id_obj, pair_obj_right,
Functor.const_obj_obj, Over.mk_hom, Functor.id_map, CostructuredArrow.right_eq_id]
at hm₁ this
simp [← hm₁, this] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.AlgebraicGeometry.Gluing | {
"line": 279,
"column": 2
} | {
"line": 284,
"column": 8
} | [
{
"pp": "X : Scheme\n𝒰 : X.OpenCover\nx y z : 𝒰.I₀\n⊢ pullback (pullback.fst (𝒰.f x) (𝒰.f y)) (pullback.fst (𝒰.f x) (𝒰.f z)) ⟶\n pullback (pullback.fst (𝒰.f y) (𝒰.f z)) (pullback.fst (𝒰.f y) (𝒰.f x))",
"usedConstants": [
"CategoryTheory.Limits.pullbackSymmetry",
"CategoryTheory.Limi... | refine (pullbackRightPullbackFstIso _ _ _).hom ≫ ?_
refine ?_ ≫ (pullbackSymmetry _ _).hom
refine ?_ ≫ (pullbackRightPullbackFstIso _ _ _).inv
refine pullback.map _ _ _ _ (pullbackSymmetry _ _).hom (𝟙 _) (𝟙 _) ?_ ?_
· simp [pullback.condition]
· simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.AlgebraicGeometry.Gluing | {
"line": 279,
"column": 2
} | {
"line": 284,
"column": 8
} | [
{
"pp": "X : Scheme\n𝒰 : X.OpenCover\nx y z : 𝒰.I₀\n⊢ pullback (pullback.fst (𝒰.f x) (𝒰.f y)) (pullback.fst (𝒰.f x) (𝒰.f z)) ⟶\n pullback (pullback.fst (𝒰.f y) (𝒰.f z)) (pullback.fst (𝒰.f y) (𝒰.f x))",
"usedConstants": [
"CategoryTheory.Limits.pullbackSymmetry",
"CategoryTheory.Limi... | refine (pullbackRightPullbackFstIso _ _ _).hom ≫ ?_
refine ?_ ≫ (pullbackSymmetry _ _).hom
refine ?_ ≫ (pullbackRightPullbackFstIso _ _ _).inv
refine pullback.map _ _ _ _ (pullbackSymmetry _ _).hom (𝟙 _) (𝟙 _) ?_ ?_
· simp [pullback.condition]
· simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.AlgebraicGeometry.AffineScheme | {
"line": 534,
"column": 4
} | {
"line": 534,
"column": 24
} | [
{
"pp": "X Y : Scheme\nU : Y.Opens\nhU : IsAffineOpen U\nf : X ⟶ Y\ninst✝ : IsOpenImmersion f\nhU' : U ≤ Scheme.Hom.opensRange f\n⊢ IsAffineOpen (Scheme.Hom.opensRange f ⊓ U)",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"AlgebraicGeometry.SheafedSpace.instTopologicalSpaceCarrierCarrier",
... | inf_eq_right.mpr hU' | Lean.Elab.Tactic.evalRewriteSeq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.