module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | {
"line": 141,
"column": 55
} | {
"line": 149,
"column": 39
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nJ : GrothendieckTopology C\nA : Type u'\ninst✝¹ : Category.{v', u'} A\nH : J.OneHypercoverFamily\nP : Cᵒᵖ ⥤ A\ninst✝ : H.IsGenerating\n⊢ Presheaf.IsSheaf J P ↔ ∀ ⦃X : C⦄ (E : J.OneHypercover X), H E → Nonempty (IsLimit (E.multifork P))",
"usedConstants": [
... | by
constructor
· intro hP X E _
exact ⟨E.isLimitMultifork ⟨_, hP⟩⟩
· intro hP
rw [Presheaf.isSheaf_iff_multifork]
rintro X ⟨S, hS⟩
obtain ⟨E, hE, le⟩ := H.exists_oneHypercover S hS
exact ⟨IsSheafIff.isLimit hP hE le⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Sites.CoverPreserving | {
"line": 131,
"column": 2
} | {
"line": 131,
"column": 22
} | [
{
"pp": "case compatible\nC : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nK : GrothendieckTopology D\nG : C ⥤ D\ninst✝ : RepresentablyFlat G\nℱ : Sheaf K (Type u_1)\nZ : C\nT : Presieve Z\nx : FamilyOfElements (G.op ⋙ ℱ.obj) T\nhx : x.Compatible\nY₁ Y₂ : C\nX : D\nf₁ : X ⟶ ... | conv_rhs => rw [eq₂] | Mathlib.Tactic.Conv._aux_Mathlib_Tactic_Conv___macroRules_Mathlib_Tactic_Conv_convRHS_1 | Mathlib.Tactic.Conv.convRHS |
Mathlib.CategoryTheory.Sites.Continuous | {
"line": 311,
"column": 4
} | {
"line": 311,
"column": 69
} | [
{
"pp": "C : Type u₁\ninst✝⁶ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝⁵ : Category.{v₂, u₂} D\nF : C ⥤ D\nJ : Precoverage C\nK : Precoverage D\ninst✝⁴ : J.IsStableUnderBaseChange\ninst✝³ : J.HasPullbacks\ninst✝² : K.IsStableUnderBaseChange\ninst✝¹ : K.HasPullbacks\ninst✝ : J.PullbacksPreservedBy F\nh : J ≤ Prec... | have : R.HasPairwisePullbacks := J.hasPairwisePullbacks_of_mem hR | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.CategoryTheory.Sites.Equivalence | {
"line": 70,
"column": 4
} | {
"line": 71,
"column": 85
} | [
{
"pp": "case h.h.h\nC : Type u₁\ninst✝² : Category.{v₁, u₁} C\nJ : GrothendieckTopology C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nK : GrothendieckTopology D\ne : C ≌ D\nG : D ⥤ C\nA : Type u₃\ninst✝ : Category.{v₃, u₃} A\nX : C\nS : Sieve X\n⊢ S ∈ J X ↔ S ∈ (e.functor.inducedTopology (e.inverse.inducedTopo... | rw [show S ∈ (e.functor.inducedTopology (e.inverse.inducedTopology J)) X ↔ _
from (GrothendieckTopology.pullback_mem_iff_of_isIso (i := e.unit.app X)).symm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Sites.Equivalence | {
"line": 182,
"column": 4
} | {
"line": 183,
"column": 44
} | [
{
"pp": "C : Type u₁\ninst✝⁵ : Category.{v₁, u₁} C\nJ : GrothendieckTopology C\nD : Type u₂\ninst✝⁴ : Category.{v₂, u₂} D\nK : GrothendieckTopology D\ne : C ≌ D\ninst✝³ : IsDenseSubsite K J e.inverse\nA : Type u_1\ninst✝² : Category.{v_1, u_1} A\nB : Type u_2\ninst✝¹ : Category.{v_2, u_2} B\nF : A ⥤ B\ninst✝ : ... | replace hP' : Presheaf.IsSheaf J (e.functor.op ⋙ e.inverse.op ⋙ P ⋙ F) :=
e.functor.op_comp_isSheaf _ _ ⟨_, hP'⟩ | Lean.Elab.Tactic.evalReplace | Lean.Parser.Tactic.replace |
Mathlib.CategoryTheory.Sites.Hypercover.One | {
"line": 201,
"column": 4
} | {
"line": 205,
"column": 42
} | [
{
"pp": "case refine_2\nC : Type u\ninst✝³ : Category.{v, u} C\nA : Type u_1\ninst✝² : Category.{v_1, u_1} A\nS : C\nE : PreOneHypercover S\nc : Cofan E.X\nhc : IsColimit c\nd : Cofan E.Y'\nhd : IsColimit d\nF : Cᵒᵖ ⥤ A\ninst✝¹ : PreservesLimit (Discrete.functor fun i ↦ op (E.X i)) F\ninst✝ : PreservesLimit (Di... | refine Fan.IsLimit.hom_ext hd' _ _ fun i ↦ ?_
simp only [multicospanShape_L, multicospanIndex_right, multicospanShape_R, Iso.refl_hom,
Y'_apply, id_comp, comp_id]
rw [MulticospanIndex.sndPiMapOfIsLimit_proj]
simp [c', d', ← F.map_comp, ← op_comp] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Sites.Hypercover.One | {
"line": 201,
"column": 4
} | {
"line": 205,
"column": 42
} | [
{
"pp": "case refine_2\nC : Type u\ninst✝³ : Category.{v, u} C\nA : Type u_1\ninst✝² : Category.{v_1, u_1} A\nS : C\nE : PreOneHypercover S\nc : Cofan E.X\nhc : IsColimit c\nd : Cofan E.Y'\nhd : IsColimit d\nF : Cᵒᵖ ⥤ A\ninst✝¹ : PreservesLimit (Discrete.functor fun i ↦ op (E.X i)) F\ninst✝ : PreservesLimit (Di... | refine Fan.IsLimit.hom_ext hd' _ _ fun i ↦ ?_
simp only [multicospanShape_L, multicospanIndex_right, multicospanShape_R, Iso.refl_hom,
Y'_apply, id_comp, comp_id]
rw [MulticospanIndex.sndPiMapOfIsLimit_proj]
simp [c', d', ← F.map_comp, ← op_comp] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Sites.Over | {
"line": 252,
"column": 33
} | {
"line": 252,
"column": 45
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nJ : GrothendieckTopology C\nX : C\nx✝² : Sheaf J (Type u_1)\nZ : Over X\nx✝¹ : Presieve Z\nx✝ : Presieve.FamilyOfElements ((Over.forget X).op ⋙ x✝².obj) x✝¹\nhx : x✝.Compatible\nY₁ Y₂ : Over X\nW : C\nf₁ : W ⟶ (Over.forget X).obj Y₁\nf₂ : W ⟶ (Over.forget X).obj Y... | ext; exact h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Sites.Over | {
"line": 252,
"column": 33
} | {
"line": 252,
"column": 45
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nJ : GrothendieckTopology C\nX : C\nx✝² : Sheaf J (Type u_1)\nZ : Over X\nx✝¹ : Presieve Z\nx✝ : Presieve.FamilyOfElements ((Over.forget X).op ⋙ x✝².obj) x✝¹\nhx : x✝.Compatible\nY₁ Y₂ : Over X\nW : C\nf₁ : W ⟶ (Over.forget X).obj Y₁\nf₂ : W ⟶ (Over.forget X).obj Y... | ext; exact h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Sites.Over | {
"line": 312,
"column": 4
} | {
"line": 314,
"column": 29
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nJ : GrothendieckTopology C\nD : Type u_1\ninst✝¹ : Category.{v_1, u_1} D\nK : GrothendieckTopology D\nF : C ⥤ D\nX : C\ninst✝ : F.IsCocontinuous J K\nU : Over X\nS : Sieve ((Over.post F).obj U)\nhS : S ∈ (K.over (F.obj X)) ((Over.post F).obj U)\n⊢ Sieve.functorPu... | rw [GrothendieckTopology.mem_over_iff] at hS ⊢
rw [Sieve.overEquiv_functorPullback_post]
exact F.cover_lift J K hS | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Sites.Over | {
"line": 312,
"column": 4
} | {
"line": 314,
"column": 29
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nJ : GrothendieckTopology C\nD : Type u_1\ninst✝¹ : Category.{v_1, u_1} D\nK : GrothendieckTopology D\nF : C ⥤ D\nX : C\ninst✝ : F.IsCocontinuous J K\nU : Over X\nS : Sieve ((Over.post F).obj U)\nhS : S ∈ (K.over (F.obj X)) ((Over.post F).obj U)\n⊢ Sieve.functorPu... | rw [GrothendieckTopology.mem_over_iff] at hS ⊢
rw [Sieve.overEquiv_functorPullback_post]
exact F.cover_lift J K hS | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Sites.Hypercover.One | {
"line": 695,
"column": 73
} | {
"line": 697,
"column": 23
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nS : C\nE F : PreOneHypercover S\ne : E ≅ F\ni j : E.I₀\nk : E.I₁ i j\n⊢ e.inv.s₁ (e.hom.s₁ k) = (congrIndexOneOfEq ⋯ ⋯) k",
"usedConstants": [
"CategoryTheory.PreOneHypercover.Hom.s₁",
"CategoryTheory.PreZeroHypercover.Hom.h₀",
"Equiv.instEqu... | by
obtain ⟨hs₀, hh₀, hs₁, hh₁⟩ := PreOneHypercover.Hom.ext'_iff.mp e.hom_inv_id
simpa using hs₁ i j k | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Sites.Hypercover.One | {
"line": 930,
"column": 4
} | {
"line": 930,
"column": 16
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nA : Type u_1\ninst✝ : Category.{v_1, u_1} A\nJ : GrothendieckTopology C\nS : C\nE : J.OneHypercover S\nF : Sheaf J A\n⊢ ∀ (E_1 : Multifork (E.multicospanIndex F.obj)) (m : E_1.pt ⟶ (E.multifork F.obj).pt),\n (∀ (i : E.multicospanShape.L), m ≫ (E.multifork F.ob... | intro c m hm | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Algebra.Category.Semigrp.Basic | {
"line": 445,
"column": 4
} | {
"line": 447,
"column": 34
} | [
{
"pp": "X✝ Y✝ : Type u\nX Y : Semigrp\nf : X ⟶ Y\nx✝ : IsIso ((forget Semigrp).map f)\n⊢ IsIso f",
"usedConstants": [
"MulHom",
"Semigroup.toMul",
"Equiv.right_inv",
"Semigrp.Hom.hom",
"CategoryTheory.Iso.toEquiv",
"MulHom.map_mul'",
"Equiv.mk",
"Equiv",
... | let i := asIso ((forget Semigrp).map f)
let e : X ≃* Y := { f.hom, i.toEquiv with }
exact e.toSemigrpIso.isIso_hom | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Category.Semigrp.Basic | {
"line": 445,
"column": 4
} | {
"line": 447,
"column": 34
} | [
{
"pp": "X✝ Y✝ : Type u\nX Y : Semigrp\nf : X ⟶ Y\nx✝ : IsIso ((forget Semigrp).map f)\n⊢ IsIso f",
"usedConstants": [
"MulHom",
"Semigroup.toMul",
"Equiv.right_inv",
"Semigrp.Hom.hom",
"CategoryTheory.Iso.toEquiv",
"MulHom.map_mul'",
"Equiv.mk",
"Equiv",
... | let i := asIso ((forget Semigrp).map f)
let e : X ≃* Y := { f.hom, i.toEquiv with }
exact e.toSemigrpIso.isIso_hom | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Category.MonCat.Colimits | {
"line": 192,
"column": 26
} | {
"line": 192,
"column": 51
} | [
{
"pp": "case a.mul_1\nJ : Type v\ninst✝ : Category.{u, v} J\nF : J ⥤ MonCat\ns : Cocone F\nx✝¹ y✝ x x' y : Prequotient F\nx✝ : Relation F x x'\nh : descFunLift F s x = descFunLift F s x'\n⊢ descFunLift F s (x.mul y) = descFunLift F s (x'.mul y)",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOne... | exact congr_arg (· * _) h | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Category.MonCat.Colimits | {
"line": 192,
"column": 26
} | {
"line": 192,
"column": 51
} | [
{
"pp": "case a.mul_1\nJ : Type v\ninst✝ : Category.{u, v} J\nF : J ⥤ MonCat\ns : Cocone F\nx✝¹ y✝ x x' y : Prequotient F\nx✝ : Relation F x x'\nh : descFunLift F s x = descFunLift F s x'\n⊢ descFunLift F s (x.mul y) = descFunLift F s (x'.mul y)",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOne... | exact congr_arg (· * _) h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Category.MonCat.Colimits | {
"line": 192,
"column": 26
} | {
"line": 192,
"column": 51
} | [
{
"pp": "case a.mul_1\nJ : Type v\ninst✝ : Category.{u, v} J\nF : J ⥤ MonCat\ns : Cocone F\nx✝¹ y✝ x x' y : Prequotient F\nx✝ : Relation F x x'\nh : descFunLift F s x = descFunLift F s x'\n⊢ descFunLift F s (x.mul y) = descFunLift F s (x'.mul y)",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOne... | exact congr_arg (· * _) h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Constructions.EventuallyConstant | {
"line": 217,
"column": 8
} | {
"line": 217,
"column": 20
} | [
{
"pp": "J : Type u_1\nC : Type u_2\ninst✝² : Category.{v_1, u_1} J\ninst✝¹ : Category.{v_2, u_2} C\nF : J ⥤ C\ni₀ : J\nh : F.IsEventuallyConstantFrom i₀\ninst✝ : IsFiltered J\nj j' : J\nφ : j ⟶ j'\n⊢ F.map φ ≫ h.coconeιApp j' = h.coconeιApp j ≫ 𝟙 (F.obj i₀)",
"usedConstants": [
"Eq.mpr",
"Cate... | rw [comp_id] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | {
"line": 170,
"column": 4
} | {
"line": 170,
"column": 44
} | [
{
"pp": "case mpr.nonempty_cocone\nJ : Type u\ninst✝¹ : Category.{v, u} J\na✝ : IsFiltered J\nA : Type w\ninst✝ : SmallCategory A\nF : A ⥤ J\nhA : Finite (Arrow A)\n⊢ Nonempty (Cocone F)",
"usedConstants": [
"Finite",
"Nonempty.some",
"Iff.mp",
"CategoryTheory.FinCategory",
"No... | have := ((Arrow.finite_iff A).1 hA).some | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.LinearAlgebra.TensorProduct.Prod | {
"line": 66,
"column": 80
} | {
"line": 66,
"column": 88
} | [
{
"pp": "R : Type u_1\nS : Type u_2\nM₁ : Type u_3\nM₂ : Type u_4\nM₃ : Type u_5\ninst✝¹² : CommSemiring R\ninst✝¹¹ : Semiring S\ninst✝¹⁰ : AddCommMonoid M₁\ninst✝⁹ : AddCommMonoid M₂\ninst✝⁸ : AddCommMonoid M₃\ninst✝⁷ : Algebra R S\ninst✝⁶ : Module R M₁\ninst✝⁵ : Module S M₁\ninst✝⁴ : IsScalarTower R S M₁\nins... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.LinearAlgebra.TensorProduct.Prod | {
"line": 66,
"column": 80
} | {
"line": 66,
"column": 88
} | [
{
"pp": "R : Type u_1\nS : Type u_2\nM₁ : Type u_3\nM₂ : Type u_4\nM₃ : Type u_5\ninst✝¹² : CommSemiring R\ninst✝¹¹ : Semiring S\ninst✝¹⁰ : AddCommMonoid M₁\ninst✝⁹ : AddCommMonoid M₂\ninst✝⁸ : AddCommMonoid M₃\ninst✝⁷ : Algebra R S\ninst✝⁶ : Module R M₁\ninst✝⁵ : Module S M₁\ninst✝⁴ : IsScalarTower R S M₁\nins... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.LinearAlgebra.TensorProduct.Prod | {
"line": 66,
"column": 80
} | {
"line": 66,
"column": 88
} | [
{
"pp": "R : Type u_1\nS : Type u_2\nM₁ : Type u_3\nM₂ : Type u_4\nM₃ : Type u_5\ninst✝¹² : CommSemiring R\ninst✝¹¹ : Semiring S\ninst✝¹⁰ : AddCommMonoid M₁\ninst✝⁹ : AddCommMonoid M₂\ninst✝⁸ : AddCommMonoid M₃\ninst✝⁷ : Algebra R S\ninst✝⁶ : Module R M₁\ninst✝⁵ : Module S M₁\ninst✝⁴ : IsScalarTower R S M₁\nins... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Category.Ring.Under.Limits | {
"line": 80,
"column": 6
} | {
"line": 80,
"column": 14
} | [
{
"pp": "case h.add\nR S : CommRingCat\ninst✝² : Algebra ↑R ↑S\nι : Type u\nP : ι → Under R\ninst✝¹ : Fintype ι\ninst✝ : DecidableEq ι\ni : ι\nx✝ y✝ : ↑S ⊗[↑R] ((i : ι) → ↑(P i).right)\na✝¹ :\n (ConcreteCategory.hom\n (Under.Hom.right\n (Algebra.TensorProduct.map (AlgHom.id ↑S ↑S) (Pi.evalAlgHo... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.Category.Ring.Under.Limits | {
"line": 80,
"column": 6
} | {
"line": 80,
"column": 14
} | [
{
"pp": "case h.add\nR S : CommRingCat\ninst✝² : Algebra ↑R ↑S\nι : Type u\nP : ι → Under R\ninst✝¹ : Fintype ι\ninst✝ : DecidableEq ι\ni : ι\nx✝ y✝ : ↑S ⊗[↑R] ((i : ι) → ↑(P i).right)\na✝¹ :\n (ConcreteCategory.hom\n (Under.Hom.right\n (Algebra.TensorProduct.map (AlgHom.id ↑S ↑S) (Pi.evalAlgHo... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Category.Ring.Under.Limits | {
"line": 80,
"column": 6
} | {
"line": 80,
"column": 14
} | [
{
"pp": "case h.add\nR S : CommRingCat\ninst✝² : Algebra ↑R ↑S\nι : Type u\nP : ι → Under R\ninst✝¹ : Fintype ι\ninst✝ : DecidableEq ι\ni : ι\nx✝ y✝ : ↑S ⊗[↑R] ((i : ι) → ↑(P i).right)\na✝¹ :\n (ConcreteCategory.hom\n (Under.Hom.right\n (Algebra.TensorProduct.map (AlgHom.id ↑S ↑S) (Pi.evalAlgHo... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.CharP.CharAndCard | {
"line": 42,
"column": 4
} | {
"line": 42,
"column": 68
} | [
{
"pp": "case mpr\nR : Type u_1\ninst✝¹ : CommRing R\np : ℕ\ninst✝ : Fact (Nat.Prime p)\nhR : ringChar R ≠ 0\nhch : ↑(ringChar R) = 0\nhp : Nat.Prime p\nh : ¬p ∣ ringChar R\n⊢ IsUnit ↑p",
"usedConstants": [
"Iff.mpr",
"Nat.Coprime",
"Dvd.dvd",
"CommSemiring.toSemiring",
"CommRi... | rcases (hp.coprime_iff_not_dvd.mpr h).isCoprime with ⟨a, b, hab⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Algebra.CharP.CharAndCard | {
"line": 44,
"column": 4
} | {
"line": 44,
"column": 20
} | [
{
"pp": "case mpr\nR : Type u_1\ninst✝¹ : CommRing R\np : ℕ\ninst✝ : Fact (Nat.Prime p)\nhR : ringChar R ≠ 0\nhch : ↑(ringChar R) = 0\nhp : Nat.Prime p\nh : ¬p ∣ ringChar R\na b : ℤ\nhab : ↑(a * ↑p + b * ↑(ringChar R)) = ↑1\n⊢ IsUnit ↑p",
"usedConstants": [
"Int.cast",
"NonAssocSemiring.toAddCom... | push_cast at hab | Lean.Elab.Tactic.NormCast.evalPushCast | Lean.Parser.Tactic.pushCast |
Mathlib.Algebra.CharP.Invertible | {
"line": 63,
"column": 27
} | {
"line": 63,
"column": 65
} | [
{
"pp": "R : Type u_1\nK : Type u_2\ninst✝¹ : Ring R\np : ℕ\ninst✝ : CharP R p\nn : ℕ\nh : n.Coprime p\n⊢ ↑(n.gcdA p) * ↑n = 1",
"usedConstants": [
"Nat.gcd",
"Int.cast",
"Eq.mpr",
"HMul.hMul",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
"CharP.natCast_gcdA_mu... | CharP.natCast_gcdA_mul_intCast_eq_gcd, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.CharP.MixedCharZero | {
"line": 207,
"column": 6
} | {
"line": 207,
"column": 46
} | [
{
"pp": "case huv\nR : Type u_1\ninst✝¹ : CommRing R\ninst✝ : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))\n⊢ ↑⋯.unit = 1",
"usedConstants": [
"PNat.val",
"Units.val",
"Eq.mpr",
"congrArg",
"CommSemiring.toSemiring",
"AddGroupWithOne.toAddMonoidWithOne",
"id",
... | IsUnit.unit_spec (PNat.isUnit_natCast 1) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.CharP.MixedCharZero | {
"line": 351,
"column": 2
} | {
"line": 351,
"column": 95
} | [
{
"pp": "R : Type u_1\ninst✝¹ : CommRing R\nP : Prop\ninst✝ : IsDomain R\nh_pos : ∀ (p : ℕ), Nat.Prime p → CharP R p → P\nh_equal : ∀ (a : Algebra ℚ R), P\nh_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P\np : ℕ\np_pos : p ≠ 0\np_char : CharP R p\n⊢ P",
"usedConstants": [
"IsDomain.to_noZeroDi... | have p_prime : Nat.Prime p := or_iff_not_imp_right.mp (CharP.char_is_prime_or_zero R p) p_pos | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.Flat.Equalizer | {
"line": 37,
"column": 85
} | {
"line": 39,
"column": 71
} | [
{
"pp": "R : Type u_1\nS : Type u_2\ninst✝¹¹ : CommRing R\ninst✝¹⁰ : CommRing S\ninst✝⁹ : Algebra R S\nM : Type u_3\ninst✝⁸ : AddCommGroup M\ninst✝⁷ : Module R M\ninst✝⁶ : Module S M\ninst✝⁵ : IsScalarTower R S M\nN : Type u_4\nP : Type u_5\ninst✝⁴ : AddCommGroup N\ninst✝³ : AddCommGroup P\ninst✝² : Module R N\... | by
rw [← LinearMap.exact_iff]
exact Module.Flat.lTensor_exact M (LinearMap.exact_subtype_ker_map f) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Flat.Equalizer | {
"line": 92,
"column": 18
} | {
"line": 92,
"column": 26
} | [
{
"pp": "case zero\nR : Type u_1\nS : Type u_2\ninst✝¹⁰ : CommRing R\ninst✝⁹ : CommRing S\ninst✝⁸ : Algebra R S\nM : Type u_3\ninst✝⁷ : AddCommGroup M\ninst✝⁶ : Module R M\ninst✝⁵ : Module S M\ninst✝⁴ : IsScalarTower R S M\nN : Type u_4\nP : Type u_5\ninst✝³ : AddCommGroup N\ninst✝² : AddCommGroup P\ninst✝¹ : M... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Flat.Equalizer | {
"line": 92,
"column": 18
} | {
"line": 92,
"column": 26
} | [
{
"pp": "case tmul\nR : Type u_1\nS : Type u_2\ninst✝¹⁰ : CommRing R\ninst✝⁹ : CommRing S\ninst✝⁸ : Algebra R S\nM : Type u_3\ninst✝⁷ : AddCommGroup M\ninst✝⁶ : Module R M\ninst✝⁵ : Module S M\ninst✝⁴ : IsScalarTower R S M\nN : Type u_4\nP : Type u_5\ninst✝³ : AddCommGroup N\ninst✝² : AddCommGroup P\ninst✝¹ : M... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Flat.Equalizer | {
"line": 92,
"column": 18
} | {
"line": 92,
"column": 26
} | [
{
"pp": "case add\nR : Type u_1\nS : Type u_2\ninst✝¹⁰ : CommRing R\ninst✝⁹ : CommRing S\ninst✝⁸ : Algebra R S\nM : Type u_3\ninst✝⁷ : AddCommGroup M\ninst✝⁶ : Module R M\ninst✝⁵ : Module S M\ninst✝⁴ : IsScalarTower R S M\nN : Type u_4\nP : Type u_5\ninst✝³ : AddCommGroup N\ninst✝² : AddCommGroup P\ninst✝¹ : Mo... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Flat.Equalizer | {
"line": 102,
"column": 18
} | {
"line": 102,
"column": 26
} | [
{
"pp": "case zero\nR : Type u_1\nS : Type u_2\ninst✝¹⁰ : CommRing R\ninst✝⁹ : CommRing S\ninst✝⁸ : Algebra R S\nM : Type u_3\ninst✝⁷ : AddCommGroup M\ninst✝⁶ : Module R M\ninst✝⁵ : Module S M\ninst✝⁴ : IsScalarTower R S M\nN : Type u_4\nP : Type u_5\ninst✝³ : AddCommGroup N\ninst✝² : AddCommGroup P\ninst✝¹ : M... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Flat.Equalizer | {
"line": 102,
"column": 18
} | {
"line": 102,
"column": 26
} | [
{
"pp": "case tmul\nR : Type u_1\nS : Type u_2\ninst✝¹⁰ : CommRing R\ninst✝⁹ : CommRing S\ninst✝⁸ : Algebra R S\nM : Type u_3\ninst✝⁷ : AddCommGroup M\ninst✝⁶ : Module R M\ninst✝⁵ : Module S M\ninst✝⁴ : IsScalarTower R S M\nN : Type u_4\nP : Type u_5\ninst✝³ : AddCommGroup N\ninst✝² : AddCommGroup P\ninst✝¹ : M... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Flat.Equalizer | {
"line": 102,
"column": 18
} | {
"line": 102,
"column": 26
} | [
{
"pp": "case add\nR : Type u_1\nS : Type u_2\ninst✝¹⁰ : CommRing R\ninst✝⁹ : CommRing S\ninst✝⁸ : Algebra R S\nM : Type u_3\ninst✝⁷ : AddCommGroup M\ninst✝⁶ : Module R M\ninst✝⁵ : Module S M\ninst✝⁴ : IsScalarTower R S M\nN : Type u_4\nP : Type u_5\ninst✝³ : AddCommGroup N\ninst✝² : AddCommGroup P\ninst✝¹ : Mo... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Stream.Init | {
"line": 113,
"column": 42
} | {
"line": 113,
"column": 52
} | [
{
"pp": "α : Type u\na : α\ns : Stream' α\nb : α\nx✝ : a ∈ s\nn : ℕ\nh : (fun b ↦ a = b) (s.get n)\n⊢ (fun b ↦ a = b) ((b :: s).tail.get n)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Stream'",
"Stream'.get",
"Stream'.cons",
"Stream'.tail",
"Eq",
"... | tail_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Stream.Init | {
"line": 148,
"column": 73
} | {
"line": 149,
"column": 50
} | [
{
"pp": "α : Type u\nβ : Type v\nf : α → β\ns : Stream' α\n⊢ map f s = f s.head :: map f s.tail",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Stream'",
"Stream'.tail_map",
"Stream'.map",
"Eq.refl",
"Stream'.head_map",
"Stream'.eta",
"Stream'.co... | by
rw [← Stream'.eta (map f s), tail_map, head_map] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Stream.Init | {
"line": 351,
"column": 53
} | {
"line": 351,
"column": 63
} | [
{
"pp": "case succ\nα : Type u\nn : ℕ\nih : ∀ (s : Stream' α), (unfolds head tail s).get n = s.get n\ns : Stream' α\n⊢ (s.head :: unfolds head tail s.tail).tail.get n = s.tail.get n",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Stream'",
"Stream'.get",
"Stream'.cons",... | tail_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Stream.Init | {
"line": 372,
"column": 43
} | {
"line": 372,
"column": 53
} | [
{
"pp": "α : Type u\nn : ℕ\ns₁ s₂ : Stream' α\n⊢ (s₁.head :: s₂.head :: (s₁.tail ⋈ s₂.tail)).tail.tail.get (2 * n) = s₁.get n.succ",
"usedConstants": [
"Eq.mpr",
"Stream'.interleave",
"HMul.hMul",
"congrArg",
"id",
"instMulNat",
"instOfNatNat",
"Stream'",
... | tail_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Stream.Init | {
"line": 381,
"column": 43
} | {
"line": 381,
"column": 53
} | [
{
"pp": "α : Type u\nn : ℕ\ns₁ s₂ : Stream' α\n⊢ (s₁.head :: s₂.head :: (s₁.tail ⋈ s₂.tail)).tail.tail.get (2 * n + 1) = s₂.get n.succ",
"usedConstants": [
"Eq.mpr",
"Stream'.interleave",
"HMul.hMul",
"congrArg",
"id",
"instMulNat",
"instOfNatNat",
"Stream'",
... | tail_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Stream.Init | {
"line": 381,
"column": 54
} | {
"line": 381,
"column": 64
} | [
{
"pp": "α : Type u\nn : ℕ\ns₁ s₂ : Stream' α\n⊢ (s₂.head :: (s₁.tail ⋈ s₂.tail)).tail.get (2 * n + 1) = s₂.get n.succ",
"usedConstants": [
"Eq.mpr",
"Stream'.interleave",
"HMul.hMul",
"congrArg",
"id",
"instMulNat",
"instOfNatNat",
"Stream'",
"instHAdd"... | tail_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Stream.Init | {
"line": 488,
"column": 57
} | {
"line": 488,
"column": 67
} | [
{
"pp": "α : Type u\na : α\nl : List α\ns : Stream' α\n⊢ drop l.length (a :: (l ++ₛ s)).tail = s",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Stream'.drop",
"id",
"Stream'",
"Stream'.appendStream'",
"Stream'.cons",
"Stream'.tail",
"Eq",
"List.length... | tail_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.FieldTheory.IntermediateField.Basic | {
"line": 64,
"column": 4
} | {
"line": 64,
"column": 20
} | [
{
"pp": "K : Type u_1\nL : Type u_2\nL' : Type u_3\ninst✝⁴ : Field K\ninst✝³ : Field L\ninst✝² : Field L'\ninst✝¹ : Algebra K L\ninst✝ : Algebra K L'\nS : IntermediateField K L\n⊢ Function.Injective fun S ↦ S.carrier",
"usedConstants": [
"IntermediateField"
]
}
] | rintro ⟨⟨⟩⟩ ⟨⟨⟩⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.FieldTheory.IntermediateField.Basic | {
"line": 287,
"column": 4
} | {
"line": 288,
"column": 22
} | [
{
"pp": "case pos\nK : Type u_1\nL : Type u_2\nL' : Type u_3\ninst✝⁴ : Field K\ninst✝³ : Field L\ninst✝² : Field L'\ninst✝¹ : Algebra K L\ninst✝ : Algebra K L'\nS✝ : IntermediateField K L\nS : Subalgebra K L\nhS : IsField ↥S\nx : L\nhx : x ∈ S\nhx0 : x = 0\n⊢ x⁻¹ ∈ S",
"usedConstants": [
"Subalgebra.i... | · rw [hx0, inv_zero]
exact S.zero_mem | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Seq.Computation | {
"line": 200,
"column": 35
} | {
"line": 200,
"column": 43
} | [
{
"pp": "case h_1\nα : Type u\nβ : Type v\nγ : Type w\nf : β → α ⊕ β\nb✝ : β\na' : α\nb : β\nh :\n (match Sum.inr b with\n | Sum.inl a => (some a, Sum.inl a)\n | Sum.inr b =>\n (match f b with\n | Sum.inl a => some a\n | Sum.inr val => none,\n f b)).fst =\n some a... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Seq.Computation | {
"line": 200,
"column": 35
} | {
"line": 200,
"column": 43
} | [
{
"pp": "case h_2\nα : Type u\nβ : Type v\nγ : Type w\nf : β → α ⊕ β\nb✝ : β\na' : α\nb : β\nh :\n (match Sum.inr b with\n | Sum.inl a => (some a, Sum.inl a)\n | Sum.inr b =>\n (match f b with\n | Sum.inl a => some a\n | Sum.inr val => none,\n f b)).fst =\n some a... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Stream.Init | {
"line": 632,
"column": 52
} | {
"line": 632,
"column": 62
} | [
{
"pp": "case succ\nα : Type u\nn : ℕ\nih : ∀ (s : Stream' α), s.tails.get n = drop n s.tail\ns : Stream' α\n⊢ (s.tail :: s.tail.tails).tail.get n = drop n s.tail.tail",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Stream'.drop",
"id",
"Stream'",
"Stream'.get",
"Stream... | tail_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Stream.Init | {
"line": 655,
"column": 33
} | {
"line": 655,
"column": 43
} | [
{
"pp": "case succ\nα : Type u\na : α\nn : ℕ\nih : ∀ (l : List α) (s : Stream' α), a :: (initsCore l s).get n = (initsCore (a :: l) s).get n\nl : List α\ns : Stream' α\n⊢ a :: (l :: initsCore (l ++ [s.head]) s.tail).tail.get n = (initsCore (a :: l) s).get (n + 1)",
"usedConstants": [
"Eq.mpr",
"... | tail_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Seq.Defs | {
"line": 218,
"column": 2
} | {
"line": 225,
"column": 30
} | [
{
"pp": "case some\nα : Type u\ns : Seq α\na : α\ns' : Seq α\na' : α\nf0 : s.get? 0 = some a'\nh : Option.map (fun a' ↦ (a', s.tail)) (some a') = some (a, s')\n⊢ s = cons a s'",
"usedConstants": [
"Eq.mpr",
"Stream'.Seq",
"Option.some.noConfusion",
"congrArg",
"Subtype.casesOn"... | · obtain ⟨f, al⟩ := s
injections _ h1 h2
rw [← h2]
apply Subtype.ext
dsimp [tail, cons]
rw [h1] at f0
rw [← f0]
exact (Stream'.eta f).symm | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Seq.Computation | {
"line": 274,
"column": 8
} | {
"line": 274,
"column": 16
} | [
{
"pp": "case refine_2.refine_2\nα : Type u\nR : Computation α → Computation α → Prop\nbisim : IsBisimulation R\ns₁ s₂ : Computation α\nr✝ : R s₁ s₂\nt₁ t₂ : Stream' (Option α)\ne : ∃ s s', s.val = t₁ ∧ s'.val = t₂ ∧ R s s'\ns s' r' a' : Computation α\nr : R r'.think a'.think\nh : BisimO R r'.think.destruct a'.... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Seq.Computation | {
"line": 274,
"column": 8
} | {
"line": 274,
"column": 16
} | [
{
"pp": "case refine_2.refine_2\nα : Type u\nR : Computation α → Computation α → Prop\nbisim : IsBisimulation R\ns₁ s₂ : Computation α\nr✝ : R s₁ s₂\nt₁ t₂ : Stream' (Option α)\ne : ∃ s s', s.val = t₁ ∧ s'.val = t₂ ∧ R s s'\ns s' r' a' : Computation α\nr : R r'.think a'.think\nh : BisimO R r'.think.destruct a'.... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Seq.Computation | {
"line": 274,
"column": 8
} | {
"line": 274,
"column": 16
} | [
{
"pp": "case refine_2.refine_2\nα : Type u\nR : Computation α → Computation α → Prop\nbisim : IsBisimulation R\ns₁ s₂ : Computation α\nr✝ : R s₁ s₂\nt₁ t₂ : Stream' (Option α)\ne : ∃ s s', s.val = t₁ ∧ s'.val = t₂ ∧ R s s'\ns s' r' a' : Computation α\nr : R r'.think a'.think\nh : BisimO R r'.think.destruct a'.... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Stream.Init | {
"line": 669,
"column": 29
} | {
"line": 669,
"column": 39
} | [
{
"pp": "case a.succ\nα : Type u\ns : Stream' α\nn✝ : ℕ\n⊢ take (n✝ + 1).succ s = ([s.head] :: map (List.cons s.head) s.tail.inits).tail.get n✝",
"usedConstants": [
"Stream'.take",
"Eq.mpr",
"congrArg",
"Stream'.inits",
"id",
"instOfNatNat",
"List.cons",
"Stre... | tail_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Seq.Computation | {
"line": 544,
"column": 65
} | {
"line": 548,
"column": 26
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nf : α → β\ns : Stream' (Option α)\nal : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a\nn : ℕ\nb : β\n⊢ Stream'.map (fun o ↦ Option.casesOn o none (some ∘ f)) s n = some b →\n Stream'.map (fun o ↦ Option.casesOn o none (some ∘ f)) s (n + 1) = some b",
"u... | by
dsimp [Stream'.map, Stream'.get]
rcases e : s n with - | a <;> intro h
· contradiction
· rw [al e]; exact h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Seq.Defs | {
"line": 313,
"column": 2
} | {
"line": 322,
"column": 25
} | [
{
"pp": "α : Type u\nβ : Type v\nf : β → Option (α × β)\nb : β\n⊢ (corec f b).destruct = omap (corec f) (f b)",
"usedConstants": [
"Eq.mpr",
"Stream'.Seq",
"Stream'.corec'_eq",
"congrArg",
"Option.casesOn",
"Option.some",
"id",
"Stream'.Seq.omap.match_1",
... | dsimp [corec, destruct, get]
rw [show Stream'.corec' (Corec.f f) (some b) 0 = (Corec.f f (some b)).1 from rfl]
dsimp [Corec.f]
rcases h : f b with - | s; · rfl
obtain ⟨a, b'⟩ := s; dsimp [Corec.f]
apply congr_arg fun b' => some (a, b')
apply Subtype.ext
dsimp [corec, tail]
rw [Stream'.corec'_eq, Stream'... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Seq.Defs | {
"line": 313,
"column": 2
} | {
"line": 322,
"column": 25
} | [
{
"pp": "α : Type u\nβ : Type v\nf : β → Option (α × β)\nb : β\n⊢ (corec f b).destruct = omap (corec f) (f b)",
"usedConstants": [
"Eq.mpr",
"Stream'.Seq",
"Stream'.corec'_eq",
"congrArg",
"Option.casesOn",
"Option.some",
"id",
"Stream'.Seq.omap.match_1",
... | dsimp [corec, destruct, get]
rw [show Stream'.corec' (Corec.f f) (some b) 0 = (Corec.f f (some b)).1 from rfl]
dsimp [Corec.f]
rcases h : f b with - | s; · rfl
obtain ⟨a, b'⟩ := s; dsimp [Corec.f]
apply congr_arg fun b' => some (a, b')
apply Subtype.ext
dsimp [corec, tail]
rw [Stream'.corec'_eq, Stream'... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Seq.Defs | {
"line": 397,
"column": 2
} | {
"line": 397,
"column": 10
} | [
{
"pp": "α : Type u\ns₁ s₂ : Seq α\nmotive : Seq α → Seq α → Prop\nbase : motive s₁ s₂\nstep :\n ∀ (s₁ s₂ : Seq α),\n motive s₁ s₂ → s₁ = nil ∧ s₂ = nil ∨ ∃ x s₁' s₂', s₁ = cons x s₁' ∧ s₂ = cons x s₂' ∧ motive s₁' s₂'\n⊢ IsBisimulation motive",
"usedConstants": [
"Stream'.Seq"
]
}
] | intro s₁ | Lean.Elab.Tactic.evalIntro | null |
Mathlib.Data.Seq.Defs | {
"line": 413,
"column": 2
} | {
"line": 413,
"column": 10
} | [
{
"pp": "α : Type u\ns₁ s₂ : Seq α\nmotive : Seq α → Seq α → Prop\nbase : motive s₁ s₂\nstep : ∀ (s₁ s₂ : Seq α), motive s₁ s₂ → s₁ = s₂ ∨ ∃ x s₁' s₂', s₁ = cons x s₁' ∧ s₂ = cons x s₂' ∧ motive s₁' s₂'\nmotive' : Seq α → Seq α → Prop := ⋯\n⊢ ∀ (s₁ s₂ : Seq α),\n motive' s₁ s₂ → s₁ = nil ∧ s₂ = nil ∨ ∃ x s₁'... | intro s₁ | Lean.Elab.Tactic.evalIntro | null |
Mathlib.Algebra.ContinuedFractions.Computation.Translations | {
"line": 108,
"column": 4
} | {
"line": 108,
"column": 50
} | [
{
"pp": "case zero\nK : Type u_1\ninst✝³ : DivisionRing K\ninst✝² : LinearOrder K\ninst✝¹ : FloorRing K\ninst✝ : IsStrictOrderedRing K\na : ℤ\n⊢ (IntFractPair.of ↑a).fr = 0",
"usedConstants": [
"Int.cast",
"Int.floor",
"congrArg",
"Int.fract",
"GenContFract.IntFractPair",
... | simp only [IntFractPair.of, Int.fract_intCast] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Seq.Basic | {
"line": 408,
"column": 28
} | {
"line": 408,
"column": 45
} | [
{
"pp": "case some\nα : Type u\nβ : Type v\nf : α → β\nb : β\ns : Seq α\ng : Stream' (Option α)\nal : g.IsSeq\nh : b ∈ map f ⟨g, al⟩\na : α\nom : some a ∈ g\nh' : f a = b\n⊢ ∃ a ∈ ⟨g, al⟩, f a = b",
"usedConstants": [
"Stream'.Seq",
"Membership.mem",
"Subtype.mk",
"Stream'",
"S... | exact ⟨a, om, h'⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Nat.Fib.Basic | {
"line": 93,
"column": 83
} | {
"line": 94,
"column": 41
} | [
{
"pp": "n : ℕ\n⊢ fib (n + 2) - fib (n + 1) = fib n",
"usedConstants": [
"Eq.mpr",
"Nat.instOrderedSub",
"Nat.instIsOrderedAddMonoid",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"congrArg",
"HSub.hSub",
"Nat.fib_add_two",
"Nat.instAddCancelCommMonoid",
... | by
rw [fib_add_two, add_tsub_cancel_right] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Seq.Basic | {
"line": 534,
"column": 4
} | {
"line": 541,
"column": 9
} | [
{
"pp": "case succ\nα : Type u\ns : Seq α\nn : ℕ\n⊢ (s.drop (n + 1)).length' = s.length' - ↑(n + 1)",
"usedConstants": [
"Eq.mpr",
"Stream'.Seq",
"instAddMonoidWithOneENat",
"Stream'.Seq.length'",
"AddMonoid.toAddSemigroup",
"_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.... | cases s with
| nil => simp
| cons x s =>
simp only [drop_succ_cons, length'_cons, Nat.cast_add, Nat.cast_one]
convert! drop_length' using 1
generalize s.length' = m
enat_to_nat
lia | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Data.Seq.Basic | {
"line": 534,
"column": 4
} | {
"line": 541,
"column": 9
} | [
{
"pp": "case succ\nα : Type u\ns : Seq α\nn : ℕ\n⊢ (s.drop (n + 1)).length' = s.length' - ↑(n + 1)",
"usedConstants": [
"Eq.mpr",
"Stream'.Seq",
"instAddMonoidWithOneENat",
"Stream'.Seq.length'",
"AddMonoid.toAddSemigroup",
"_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.... | cases s with
| nil => simp
| cons x s =>
simp only [drop_succ_cons, length'_cons, Nat.cast_add, Nat.cast_one]
convert! drop_length' using 1
generalize s.length' = m
enat_to_nat
lia | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Seq.Basic | {
"line": 534,
"column": 4
} | {
"line": 541,
"column": 9
} | [
{
"pp": "case succ\nα : Type u\ns : Seq α\nn : ℕ\n⊢ (s.drop (n + 1)).length' = s.length' - ↑(n + 1)",
"usedConstants": [
"Eq.mpr",
"Stream'.Seq",
"instAddMonoidWithOneENat",
"Stream'.Seq.length'",
"AddMonoid.toAddSemigroup",
"_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.... | cases s with
| nil => simp
| cons x s =>
simp only [drop_succ_cons, length'_cons, Nat.cast_add, Nat.cast_one]
convert! drop_length' using 1
generalize s.length' = m
enat_to_nat
lia | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.ContinuedFractions.Computation.TerminatesIffRat | {
"line": 196,
"column": 2
} | {
"line": 196,
"column": 10
} | [
{
"pp": "K : Type u_1\ninst✝³ : Field K\ninst✝² : LinearOrder K\ninst✝¹ : IsStrictOrderedRing K\ninst✝ : FloorRing K\nv : K\nq : ℚ\nv_eq_q : v = ↑q\n⊢ ↑(of q).h = (of v).h",
"usedConstants": [
"Int.cast",
"Rat.cast_intCast",
"DivisionRing.toRatCast",
"Int.floor",
"congrArg",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.ContinuedFractions.Computation.TerminatesIffRat | {
"line": 196,
"column": 2
} | {
"line": 196,
"column": 10
} | [
{
"pp": "K : Type u_1\ninst✝³ : Field K\ninst✝² : LinearOrder K\ninst✝¹ : IsStrictOrderedRing K\ninst✝ : FloorRing K\nv : K\nq : ℚ\nv_eq_q : v = ↑q\n⊢ ↑(of q).h = (of v).h",
"usedConstants": [
"Int.cast",
"Rat.cast_intCast",
"DivisionRing.toRatCast",
"Int.floor",
"congrArg",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.ContinuedFractions.Computation.TerminatesIffRat | {
"line": 196,
"column": 2
} | {
"line": 196,
"column": 10
} | [
{
"pp": "K : Type u_1\ninst✝³ : Field K\ninst✝² : LinearOrder K\ninst✝¹ : IsStrictOrderedRing K\ninst✝ : FloorRing K\nv : K\nq : ℚ\nv_eq_q : v = ↑q\n⊢ ↑(of q).h = (of v).h",
"usedConstants": [
"Int.cast",
"Rat.cast_intCast",
"DivisionRing.toRatCast",
"Int.floor",
"congrArg",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.ContinuedFractions.Computation.TerminatesIffRat | {
"line": 195,
"column": 86
} | {
"line": 196,
"column": 10
} | [
{
"pp": "K : Type u_1\ninst✝³ : Field K\ninst✝² : LinearOrder K\ninst✝¹ : IsStrictOrderedRing K\ninst✝ : FloorRing K\nv : K\nq : ℚ\nv_eq_q : v = ↑q\n⊢ ↑(of q).h = (of v).h",
"usedConstants": [
"Int.cast",
"Rat.cast_intCast",
"DivisionRing.toRatCast",
"Int.floor",
"congrArg",
... | by
simp_all | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Idempotents | {
"line": 242,
"column": 71
} | {
"line": 242,
"column": 74
} | [
{
"pp": "case refine_1\nR : Type u_1\nS : Type u_2\ninst✝¹ : Ring R\ninst✝ : Ring S\nf : R →+* S\nh : ∀ x ∈ RingHom.ker f, IsNilpotent x\ne₂ : R\nhe₂ : IsIdempotentElem e₂\ne' : R\nh₁ : IsIdempotentElem e'\nh₂ : e' * e₂ = 0\nhe : f e' ∈ f.range\nhe₁ : IsIdempotentElem (f e')\nhe₁e₂ : f e' * f e₂ = 0\nhe₂e₁ : f ... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Idempotents | {
"line": 244,
"column": 19
} | {
"line": 244,
"column": 22
} | [
{
"pp": "case refine_3\nR : Type u_1\nS : Type u_2\ninst✝¹ : Ring R\ninst✝ : Ring S\nf : R →+* S\nh : ∀ x ∈ RingHom.ker f, IsNilpotent x\ne₂ : R\nhe₂ : IsIdempotentElem e₂\ne' : R\nh₁ : IsIdempotentElem e'\nh₂ : e' * e₂ = 0\nhe : f e' ∈ f.range\nhe₁ : IsIdempotentElem (f e')\nhe₁e₂ : f e' * f e₂ = 0\nhe₂e₁ : f ... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Idempotents | {
"line": 392,
"column": 2
} | {
"line": 392,
"column": 49
} | [
{
"pp": "R : Type u_1\ninst✝¹ : CommRing R\nI : Type u_3\ninst✝ : Finite I\ne : I → R\nhe : OrthogonalIdempotents e\ni j : I\nhij : i ≠ j\n⊢ IsCoprime (1 - e i) (1 - e j)",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.... | exact ⟨1, e i, by simp [mul_sub, he.ortho hij]⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.LinearAlgebra.Eigenspace.Basic | {
"line": 245,
"column": 49
} | {
"line": 245,
"column": 84
} | [
{
"pp": "K : Type v\nV : Type w\ninst✝² : Field K\ninst✝¹ : AddCommGroup V\ninst✝ : Module K V\nf : End K V\na b : K\nhb : b ≠ 0\n⊢ (b • (f - b⁻¹ • a • 1)).ker = (b • f - a • 1).ker",
"usedConstants": [
"Module.End.instRing",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"Submodule",
... | by rw [smul_sub, smul_inv_smul₀ hb] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.LinearAlgebra.Eigenspace.Basic | {
"line": 474,
"column": 15
} | {
"line": 474,
"column": 23
} | [
{
"pp": "R : Type v\nM : Type w\ninst✝² : CommRing R\ninst✝¹ : AddCommGroup M\ninst✝ : Module R M\nf : End R M\nμ : R\nn : ℕ∞\nx : M\nhk : ↑0 ≤ n\nhx : ((f - μ • 1) ^ 0) x = 0\n⊢ ((f - μ • 1) ^ 0) (f x) = 0",
"usedConstants": [
"MulOne.toOne",
"instHSMul",
"Module.End.instMonoid",
"S... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.LinearAlgebra.Eigenspace.Basic | {
"line": 474,
"column": 15
} | {
"line": 474,
"column": 23
} | [
{
"pp": "R : Type v\nM : Type w\ninst✝² : CommRing R\ninst✝¹ : AddCommGroup M\ninst✝ : Module R M\nf : End R M\nμ : R\nn : ℕ∞\nx : M\nhk : ↑0 ≤ n\nhx : ((f - μ • 1) ^ 0) x = 0\n⊢ ((f - μ • 1) ^ 0) (f x) = 0",
"usedConstants": [
"MulOne.toOne",
"instHSMul",
"Module.End.instMonoid",
"S... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.LinearAlgebra.Eigenspace.Basic | {
"line": 474,
"column": 15
} | {
"line": 474,
"column": 23
} | [
{
"pp": "R : Type v\nM : Type w\ninst✝² : CommRing R\ninst✝¹ : AddCommGroup M\ninst✝ : Module R M\nf : End R M\nμ : R\nn : ℕ∞\nx : M\nhk : ↑0 ≤ n\nhx : ((f - μ • 1) ^ 0) x = 0\n⊢ ((f - μ • 1) ^ 0) (f x) = 0",
"usedConstants": [
"MulOne.toOne",
"instHSMul",
"Module.End.instMonoid",
"S... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.Trace | {
"line": 189,
"column": 2
} | {
"line": 193,
"column": 6
} | [
{
"pp": "R : Type u_1\ninst✝⁴ : CommRing R\nM : Type u_2\ninst✝³ : AddCommGroup M\ninst✝² : Module R M\ninst✝¹ : Free R M\ninst✝ : Module.Finite R M\n⊢ (trace R M) 1 = ↑(finrank R M)",
"usedConstants": [
"LinearMap.trace",
"Nontrivial",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWith... | cases subsingleton_or_nontrivial R
· simp [eq_iff_true_of_subsingleton]
have b := Module.Free.chooseBasis R M
rw [trace_eq_matrix_trace R b, toMatrix_one, finrank_eq_card_chooseBasisIndex]
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.LinearAlgebra.Trace | {
"line": 189,
"column": 2
} | {
"line": 193,
"column": 6
} | [
{
"pp": "R : Type u_1\ninst✝⁴ : CommRing R\nM : Type u_2\ninst✝³ : AddCommGroup M\ninst✝² : Module R M\ninst✝¹ : Free R M\ninst✝ : Module.Finite R M\n⊢ (trace R M) 1 = ↑(finrank R M)",
"usedConstants": [
"LinearMap.trace",
"Nontrivial",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWith... | cases subsingleton_or_nontrivial R
· simp [eq_iff_true_of_subsingleton]
have b := Module.Free.chooseBasis R M
rw [trace_eq_matrix_trace R b, toMatrix_one, finrank_eq_card_chooseBasisIndex]
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.Eigenspace.Basic | {
"line": 688,
"column": 38
} | {
"line": 688,
"column": 82
} | [
{
"pp": "R : Type v\nM : Type w\ninst✝⁴ : CommRing R\ninst✝³ : AddCommGroup M\ninst✝² : Module R M\ninst✝¹ : IsDomain R\ninst✝ : IsTorsionFree R M\nf : End R M\nk : ℕ∞\nμ₁ μ₂ : R\ns : Finset R\na✝ : μ₂ ∉ s\nhμ₁₂✝ : μ₁ ∉ insert μ₂ s\nhμ₁₂ : μ₁ ≠ μ₂\nhμ₁ : μ₁ ∉ s\nih : Disjoint ((f.genEigenspace μ₁) k) (s.sup fun... | ← (f.disjoint_genEigenspace hμ₁₂ k k).eq_bot | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Field.GeomSum | {
"line": 49,
"column": 2
} | {
"line": 50,
"column": 62
} | [
{
"pp": "K : Type u_2\ninst✝ : DivisionRing K\nx y : K\nh : Commute x y\nhxy : x ≠ y\nm n : ℕ\nhmn : m ≤ n\n⊢ ∑ i ∈ Ico m n, x ^ i * y ^ (n - 1 - i) = (x ^ n - y ^ (n - m) * x ^ m) / (x - y)",
"usedConstants": [
"Eq.mpr",
"False",
"instHDiv",
"HMul.hMul",
"eq_false",
"Rin... | have : x - y ≠ 0 := by simp_all [sub_eq_iff_eq_add]
rw [← h.geom_sum₂_Ico_mul hmn, mul_div_cancel_right₀ _ this] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Field.GeomSum | {
"line": 49,
"column": 2
} | {
"line": 50,
"column": 62
} | [
{
"pp": "K : Type u_2\ninst✝ : DivisionRing K\nx y : K\nh : Commute x y\nhxy : x ≠ y\nm n : ℕ\nhmn : m ≤ n\n⊢ ∑ i ∈ Ico m n, x ^ i * y ^ (n - 1 - i) = (x ^ n - y ^ (n - m) * x ^ m) / (x - y)",
"usedConstants": [
"Eq.mpr",
"False",
"instHDiv",
"HMul.hMul",
"eq_false",
"Rin... | have : x - y ≠ 0 := by simp_all [sub_eq_iff_eq_add]
rw [← h.geom_sum₂_Ico_mul hmn, mul_div_cancel_right₀ _ this] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Field.Periodic | {
"line": 75,
"column": 45
} | {
"line": 75,
"column": 99
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nf : α → β\nc : α\ninst✝ : DivisionSemiring α\nh : Periodic f c\na : α\n⊢ Periodic (fun x ↦ f (x / a)) (c * a)",
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"GroupWithZero.toDivInvMonoid",
"Monoid.toMulOn... | by simpa only [div_eq_mul_inv] using h.mul_const_inv a | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.FreeMonoid.Count | {
"line": 50,
"column": 31
} | {
"line": 50,
"column": 53
} | [
{
"pp": "α : Type u_1\np : α → Prop\ninst✝ : DecidablePred p\nx : α\n⊢ Multiplicative.ofAdd (List.countP (fun b ↦ decide (p b)) [x]) =\n if p x then Multiplicative.ofAdd 1 else Multiplicative.ofAdd 0",
"usedConstants": [
"Eq.mpr",
"List.countP",
"Equiv.instEquivLike",
"congrArg",
... | List.countP_singleton, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.FreeMonoid.FreeSemigroup | {
"line": 94,
"column": 32
} | {
"line": 94,
"column": 40
} | [
{
"pp": "case coe.ih1\nα : Type u_1\nx✝ : α\n⊢ (lift fun x ↦ ↑(FreeSemigroup.of x)) ((WithOne.lift toFreeMonoid) ↑(FreeSemigroup.of x✝)) = ↑(FreeSemigroup.of x✝)",
"usedConstants": [
"WithOne",
"FreeSemigroup.of",
"WithOne.coe",
"eq_self",
"of_eq_true",
"FreeSemigroup",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.FreeMonoid.FreeSemigroup | {
"line": 94,
"column": 32
} | {
"line": 94,
"column": 40
} | [
{
"pp": "case coe.ih2\nα : Type u_1\nx✝ : α\ny✝ : FreeSemigroup α\na✝¹ : (lift fun x ↦ ↑(FreeSemigroup.of x)) ((WithOne.lift toFreeMonoid) ↑(FreeSemigroup.of x✝)) = ↑(FreeSemigroup.of x✝)\na✝ : (lift fun x ↦ ↑(FreeSemigroup.of x)) ((WithOne.lift toFreeMonoid) ↑y✝) = ↑y✝\n⊢ (lift fun x ↦ ↑(FreeSemigroup.of x)) (... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.FiveLemma | {
"line": 102,
"column": 4
} | {
"line": 103,
"column": 83
} | [
{
"pp": "M₁ : Type u_1\nM₂ : Type u_2\nM₃ : Type u_3\nM₄ : Type u_4\nN₁ : Type u_6\nN₂ : Type u_7\nN₃ : Type u_8\nN₄ : Type u_9\ninst✝⁷ : Group M₁\ninst✝⁶ : Group M₂\ninst✝⁵ : Group M₃\ninst✝⁴ : Group M₄\ninst✝³ : Group N₁\ninst✝² : Group N₂\ninst✝¹ : Group N₃\ninst✝ : Group N₄\nf₁ : M₁ →* M₂\nf₂ : M₂ →* M₃\nf₃... | suffices h : i₄ (f₃ m) = 1 by rwa [map_eq_one_iff _ hi₄] at h
simp [← show g₃ (i₃ m) = i₄ (f₃ m) by simpa using DFunLike.congr_fun hc₃ m, hm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.FiveLemma | {
"line": 102,
"column": 4
} | {
"line": 103,
"column": 83
} | [
{
"pp": "M₁ : Type u_1\nM₂ : Type u_2\nM₃ : Type u_3\nM₄ : Type u_4\nN₁ : Type u_6\nN₂ : Type u_7\nN₃ : Type u_8\nN₄ : Type u_9\ninst✝⁷ : Group M₁\ninst✝⁶ : Group M₂\ninst✝⁵ : Group M₃\ninst✝⁴ : Group M₄\ninst✝³ : Group N₁\ninst✝² : Group N₂\ninst✝¹ : Group N₃\ninst✝ : Group N₄\nf₁ : M₁ →* M₂\nf₂ : M₂ →* M₃\nf₃... | suffices h : i₄ (f₃ m) = 1 by rwa [map_eq_one_iff _ hi₄] at h
simp [← show g₃ (i₃ m) = i₄ (f₃ m) by simpa using DFunLike.congr_fun hc₃ m, hm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Polynomial.Eisenstein.Basic | {
"line": 68,
"column": 2
} | {
"line": 70,
"column": 70
} | [
{
"pp": "R : Type u\ninst✝¹ : CommSemiring R\n𝓟 : Ideal R\nf : R[X]\nhf : f.IsWeaklyEisensteinAt 𝓟\nA : Type v\ninst✝ : CommSemiring A\nφ : R →+* A\n⊢ (Polynomial.map φ f).IsWeaklyEisensteinAt (Ideal.map φ 𝓟)",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Polynomial.coeff_map",
"Semir... | refine (isWeaklyEisensteinAt_iff _ _).2 fun hn => ?_
rw [coeff_map]
exact mem_map_of_mem _ (hf.mem (lt_of_lt_of_le hn natDegree_map_le)) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Polynomial.Eisenstein.Basic | {
"line": 68,
"column": 2
} | {
"line": 70,
"column": 70
} | [
{
"pp": "R : Type u\ninst✝¹ : CommSemiring R\n𝓟 : Ideal R\nf : R[X]\nhf : f.IsWeaklyEisensteinAt 𝓟\nA : Type v\ninst✝ : CommSemiring A\nφ : R →+* A\n⊢ (Polynomial.map φ f).IsWeaklyEisensteinAt (Ideal.map φ 𝓟)",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Polynomial.coeff_map",
"Semir... | refine (isWeaklyEisensteinAt_iff _ _).2 fun hn => ?_
rw [coeff_map]
exact mem_map_of_mem _ (hf.mem (lt_of_lt_of_le hn natDegree_map_le)) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Polynomial.Eisenstein.Criterion | {
"line": 87,
"column": 6
} | {
"line": 87,
"column": 14
} | [
{
"pp": "R : Type u_1\ninst✝³ : CommRing R\ninst✝² : IsDomain R\nK : Type u_2\ninst✝¹ : Field K\ninst✝ : Algebra R K\nq f g : R[X]\np : ℕ\nhq_irr : Irreducible (map (algebraMap R K) q)\nhq_monic : q.Monic\nhf_lC : (algebraMap R K) f.leadingCoeff ≠ 0\nhf_prim : f.IsPrimitive\nhfmodP : map (algebraMap R K) f = C ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Polynomial.Eisenstein.Criterion | {
"line": 87,
"column": 6
} | {
"line": 87,
"column": 14
} | [
{
"pp": "R : Type u_1\ninst✝³ : CommRing R\ninst✝² : IsDomain R\nK : Type u_2\ninst✝¹ : Field K\ninst✝ : Algebra R K\nq f g : R[X]\np : ℕ\nhq_irr : Irreducible (map (algebraMap R K) q)\nhq_monic : q.Monic\nhf_lC : (algebraMap R K) f.leadingCoeff ≠ 0\nhf_prim : f.IsPrimitive\nhfmodP : map (algebraMap R K) f = C ... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Polynomial.Eisenstein.Criterion | {
"line": 87,
"column": 6
} | {
"line": 87,
"column": 14
} | [
{
"pp": "R : Type u_1\ninst✝³ : CommRing R\ninst✝² : IsDomain R\nK : Type u_2\ninst✝¹ : Field K\ninst✝ : Algebra R K\nq f g : R[X]\np : ℕ\nhq_irr : Irreducible (map (algebraMap R K) q)\nhq_monic : q.Monic\nhf_lC : (algebraMap R K) f.leadingCoeff ≠ 0\nhf_prim : f.IsPrimitive\nhfmodP : map (algebraMap R K) f = C ... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Polynomial.Eisenstein.Criterion | {
"line": 110,
"column": 50
} | {
"line": 110,
"column": 61
} | [
{
"pp": "case right\nR : Type u_1\ninst✝³ : CommRing R\ninst✝² : IsDomain R\nK : Type u_2\ninst✝¹ : Field K\ninst✝ : Algebra R K\nq f g : R[X]\np : ℕ\nhq_irr : Irreducible (map (algebraMap R K) q)\nhq_monic : q.Monic\nhf_lC : (algebraMap R K) f.leadingCoeff ≠ 0\nhf_prim : ∀ (r : R), C r ∣ f → IsUnit r\nhfmodP :... | if_neg hg', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | {
"line": 92,
"column": 4
} | {
"line": 92,
"column": 12
} | [
{
"pp": "case refine_3\nR : Type u_1\ninst✝⁴ : CommRing R\nA : Type u_2\nB : Type u_3\ninst✝³ : CommRing A\ninst✝² : CommRing B\ninst✝¹ : Algebra R A\ninst✝ : Algebra R B\nf : A →ₐ[R] B\nhf : Function.Injective ⇑f\ninj : Function.Injective ⇑(algebraMap R B)\ncl : ∀ {x : B}, IsIntegral R x ↔ ∃ y, (algebraMap R B... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | {
"line": 117,
"column": 4
} | {
"line": 117,
"column": 12
} | [
{
"pp": "case mp\nR : Type u_1\ninst✝² : CommRing R\nA : Type u_2\ninst✝¹ : CommRing A\ninst✝ : Algebra R A\nalgebraMap_injective✝ : Function.Injective ⇑(algebraMap R A)\ncl : ∀ {x : A}, IsIntegral R x ↔ ∃ y, (algebraMap R A) y = x\n⊢ Function.Injective ⇑(algebraMap R A) ∧ ∀ {x : A}, IsIntegral R x → ∃ y, (alge... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | {
"line": 119,
"column": 20
} | {
"line": 119,
"column": 28
} | [
{
"pp": "R : Type u_1\ninst✝² : CommRing R\nA : Type u_2\ninst✝¹ : CommRing A\ninst✝ : Algebra R A\ninj : Function.Injective ⇑(algebraMap R A)\ncl : ∀ {x : A}, IsIntegral R x → ∃ y, (algebraMap R A) y = x\nx✝ : A\n⊢ IsIntegral R x✝ → ∃ y, (algebraMap R A) y = x✝",
"usedConstants": [
"Algebra.algebraMa... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | {
"line": 119,
"column": 20
} | {
"line": 119,
"column": 28
} | [
{
"pp": "R : Type u_1\ninst✝² : CommRing R\nA : Type u_2\ninst✝¹ : CommRing A\ninst✝ : Algebra R A\ninj : Function.Injective ⇑(algebraMap R A)\ncl : ∀ {x : A}, IsIntegral R x → ∃ y, (algebraMap R A) y = x\nx✝ : A\n⊢ IsIntegral R x✝ → ∃ y, (algebraMap R A) y = x✝",
"usedConstants": [
"Algebra.algebraMa... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | {
"line": 119,
"column": 20
} | {
"line": 119,
"column": 28
} | [
{
"pp": "R : Type u_1\ninst✝² : CommRing R\nA : Type u_2\ninst✝¹ : CommRing A\ninst✝ : Algebra R A\ninj : Function.Injective ⇑(algebraMap R A)\ncl : ∀ {x : A}, IsIntegral R x → ∃ y, (algebraMap R A) y = x\nx✝ : A\n⊢ IsIntegral R x✝ → ∃ y, (algebraMap R A) y = x✝",
"usedConstants": [
"Algebra.algebraMa... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.