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.Limits.Shapes.Products | {
"line": 844,
"column": 8
} | {
"line": 844,
"column": 16
} | [
{
"pp": "β : Type w\nα : Type w₂\nγ : Type w₃\nC : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Unique β\nf : β → C\ns : Cocone (Discrete.functor f)\nm :\n { pt := f default,\n ι :=\n Discrete.natTrans fun x ↦\n match x with\n | { as := j } => eqToHom ⋯ }.pt ⟶\n s.pt\nw ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | {
"line": 147,
"column": 13
} | {
"line": 147,
"column": 16
} | [
{
"pp": "case none\nC : Type u\ninst✝ : Category.{v, u} C\nF : WalkingCospan ⥤ C\ns t : Cone F\ni : s.pt ≅ t.pt\nw₁ : s.π.app left = i.hom ≫ t.π.app left\nw₂ : s.π.app right = i.hom ≫ t.π.app right\nh₁ : s.π.app one = s.π.app left ≫ F.map inl\nh₂ : t.π.app one = t.π.app left ≫ F.map inl\n⊢ s.π.app none = i.hom ... | h₂, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 493,
"column": 2
} | {
"line": 493,
"column": 90
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y : C\nh : IsInitial X\nc : BinaryCofan X Y\n⊢ Nonempty (IsColimit c) ↔ IsIso c.inr",
"usedConstants": [
"CategoryTheory.Limits.BinaryCofan.inr",
"CategoryTheory.Functor",
"CategoryTheory.IsIso",
"CategoryTheory.Functor.category",
... | refine Iff.trans ?_ (BinaryCofan.isColimit_iff_isIso_inl h (BinaryCofan.mk c.inr c.inl)) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 1578,
"column": 16
} | {
"line": 1583,
"column": 17
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX✝ Y Z P✝ X : C\ns : Cone (Functor.empty C)\nP : IsLimit s\nt : BinaryFan X s.pt\nQ : IsLimit t\n⊢ t.fst ≫ Q.lift (mk (𝟙 X) (P.lift { pt := X, π := { app := fun x ↦ x.as.elim, naturality := ⋯ } })) = 𝟙 t.pt",
"usedConstants": [
"CategoryTheory.Category... | by
apply Q.hom_ext
rintro ⟨⟨⟩⟩
· simp
· apply P.hom_ext
rintro ⟨⟨⟩⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 129,
"column": 22
} | {
"line": 129,
"column": 30
} | [
{
"pp": "T : Type u₁\ninst✝¹ : Category.{v₁, u₁} T\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nX : T\nf✝ g✝ : Over X\nφ : f✝ ⟶ g✝\nU V W : Over X\nf : U.left ⟶ V.left\ng : V.left ⟶ W.left\nw_f : f ≫ V.hom = U.hom\nw_g : g ≫ W.hom = V.hom\n⊢ (f ≫ g) ≫ W.hom = U.hom",
"usedConstants": [
"CategoryTheory.C... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 129,
"column": 22
} | {
"line": 129,
"column": 30
} | [
{
"pp": "T : Type u₁\ninst✝¹ : Category.{v₁, u₁} T\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nX : T\nf✝ g✝ : Over X\nφ : f✝ ⟶ g✝\nU V W : Over X\nf : U.left ⟶ V.left\ng : V.left ⟶ W.left\nw_f : f ≫ V.hom = U.hom\nw_g : g ≫ W.hom = V.hom\n⊢ (f ≫ g) ≫ W.hom = U.hom",
"usedConstants": [
"CategoryTheory.C... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 129,
"column": 22
} | {
"line": 129,
"column": 30
} | [
{
"pp": "T : Type u₁\ninst✝¹ : Category.{v₁, u₁} T\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nX : T\nf✝ g✝ : Over X\nφ : f✝ ⟶ g✝\nU V W : Over X\nf : U.left ⟶ V.left\ng : V.left ⟶ W.left\nw_f : f ≫ V.hom = U.hom\nw_g : g ≫ W.hom = V.hom\n⊢ (f ≫ g) ≫ W.hom = U.hom",
"usedConstants": [
"CategoryTheory.C... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX Y : Discrete PUnit.{?u.3290 + 1}\n⊢ Zero (X ⟶ Y)",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.discreteCategory",
"PUnit",
"Zero.mk",
... | (constructor) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX Y : Discrete PUnit.{?u.3290 + 1}\n⊢ Zero (X ⟶ Y)",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.discreteCategory",
"PUnit",
"Zero.mk",
... | (constructor) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX Y : Discrete PUnit.{?u.3290 + 1}\n⊢ Zero (X ⟶ Y)",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.discreteCategory",
"PUnit",
"Zero.mk",
... | (constructor) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [
{
"pp": "case zero\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX Y : Discrete PUnit.{?u.3290 + 1}\n⊢ X ⟶ Y",
"usedConstants": [
"PLift",
"CategoryTheory.Discrete.as",
"PUnit",
"ULift.up",
"Eq"
]
}
] | (constructor) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [
{
"pp": "case zero\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX Y : Discrete PUnit.{?u.3290 + 1}\n⊢ X ⟶ Y",
"usedConstants": [
"PLift",
"CategoryTheory.Discrete.as",
"PUnit",
"ULift.up",
"Eq"
]
}
] | (constructor) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [
{
"pp": "case zero\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX Y : Discrete PUnit.{?u.3290 + 1}\n⊢ X ⟶ Y",
"usedConstants": [
"PLift",
"CategoryTheory.Discrete.as",
"PUnit",
"ULift.up",
"Eq"
]
}
] | (constructor) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [
{
"pp": "case zero.down\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX Y : Discrete PUnit.{?u.3290 + 1}\n⊢ PLift (X.as = Y.as)",
"usedConstants": [
"PLift.up",
"CategoryTheory.Discrete.as",
"PUnit",
"Eq"
]
}
] | (constructor) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [
{
"pp": "case zero.down\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX Y : Discrete PUnit.{?u.3290 + 1}\n⊢ PLift (X.as = Y.as)",
"usedConstants": [
"PLift.up",
"CategoryTheory.Discrete.as",
"PUnit",
"Eq"
]
}
] | (constructor) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [
{
"pp": "case zero.down\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX Y : Discrete PUnit.{?u.3290 + 1}\n⊢ PLift (X.as = Y.as)",
"usedConstants": [
"PLift.up",
"CategoryTheory.Discrete.as",
"PUnit",
"Eq"
]
}
] | (constructor) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [
{
"pp": "case zero.down.down\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX Y : Discrete PUnit.{?u.3290 + 1}\n⊢ X.as = Y.as",
"usedConstants": [
"CategoryTheory.Discrete.as",
"PUnit",
"Eq.refl"
]
}
] | (constructor) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [
{
"pp": "case zero.down.down\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX Y : Discrete PUnit.{?u.3290 + 1}\n⊢ X.as = Y.as",
"usedConstants": [
"CategoryTheory.Discrete.as",
"PUnit",
"Eq.refl"
]
}
] | (constructor) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [
{
"pp": "case zero.down.down\nC : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u'\ninst✝ : Category.{v', u'} D\nX Y : Discrete PUnit.{?u.3290 + 1}\n⊢ X.as = Y.as",
"usedConstants": [
"CategoryTheory.Discrete.as",
"PUnit",
"Eq.refl"
]
}
] | (constructor) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [] | (constructor) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [] | (constructor) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 74,
"column": 24
} | {
"line": 74,
"column": 37
} | [] | (constructor) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 103,
"column": 14
} | {
"line": 103,
"column": 20
} | [
{
"pp": "case w\nC : Type u\ninst✝ : Category.{v, u} C\nI J : HasZeroMorphisms C\nX Y : C\nthis : Zero.zero ≫ Zero.zero = Zero.zero\nthat : Zero.zero ≫ Zero.zero = Zero.zero\n⊢ Zero.zero ≫ Zero.zero = Zero.zero",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quive... | ← that | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 516,
"column": 40
} | {
"line": 516,
"column": 48
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y : C\nf g : X ⟶ Y\nt : Cofork f g\ndesc : (s : Cofork f g) → t.pt ⟶ s.pt\nfac : ∀ (s : Cofork f g), t.π ≫ desc s = s.π\nuniq : ∀ (s : Cofork f g) (m : t.pt ⟶ s.pt), t.π ≫ m = s.π → m = desc s\ns : Cocone (parallelPair f g)\nj : WalkingParallelPair\n⊢ t.ι.app ze... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 516,
"column": 40
} | {
"line": 516,
"column": 48
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y : C\nf g : X ⟶ Y\nt : Cofork f g\ndesc : (s : Cofork f g) → t.pt ⟶ s.pt\nfac : ∀ (s : Cofork f g), t.π ≫ desc s = s.π\nuniq : ∀ (s : Cofork f g) (m : t.pt ⟶ s.pt), t.π ≫ m = s.π → m = desc s\ns : Cocone (parallelPair f g)\nj : WalkingParallelPair\n⊢ t.ι.app ze... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 516,
"column": 40
} | {
"line": 516,
"column": 48
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y : C\nf g : X ⟶ Y\nt : Cofork f g\ndesc : (s : Cofork f g) → t.pt ⟶ s.pt\nfac : ∀ (s : Cofork f g), t.π ≫ desc s = s.π\nuniq : ∀ (s : Cofork f g) (m : t.pt ⟶ s.pt), t.π ≫ m = s.π → m = desc s\ns : Cocone (parallelPair f g)\nj : WalkingParallelPair\n⊢ t.ι.app ze... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 429,
"column": 8
} | {
"line": 429,
"column": 38
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nD : Type u'\ninst✝¹ : Category.{v', u'} D\ninst✝ : HasZeroMorphisms C\nX Y : C\ni : IsIso 0\n⊢ 0 ≫ inv 0 = 0 ∧ 𝟙 Y = 0",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryT... | ← IsIso.inv_hom_id (0 : X ⟶ Y) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 990,
"column": 6
} | {
"line": 996,
"column": 35
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y : C\nf✝ g✝ f g : X ⟶ Y\nZ : C\nh✝ : Z ⟶ X\ns : Fork f g\nhs : IsLimit s\nc : PullbackCone s.ι h✝\nhc : IsLimit c\ns' : Fork (h✝ ≫ f) (h✝ ≫ g)\nm : s'.pt ⟶ (precompFork h✝ s c).pt\nh : m ≫ (precompFork h✝ s c).ι = s'.ι\n⊢ ∀ (j : WalkingCospan), m ≫ c.π.app j = ... | apply PullbackCone.equalizer_ext
· simp only [liftPrecomp, Fork.ofι_pt, IsLimit.fac, PullbackCone.mk_π_app]
apply hs.hom_ext
apply Fork.equalizer_ext
simp only [Fork.ι_ofι, precompFork] at h
simp [c.condition, reassoc_of% h]
· simpa [liftPrecomp] using h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 990,
"column": 6
} | {
"line": 996,
"column": 35
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y : C\nf✝ g✝ f g : X ⟶ Y\nZ : C\nh✝ : Z ⟶ X\ns : Fork f g\nhs : IsLimit s\nc : PullbackCone s.ι h✝\nhc : IsLimit c\ns' : Fork (h✝ ≫ f) (h✝ ≫ g)\nm : s'.pt ⟶ (precompFork h✝ s c).pt\nh : m ≫ (precompFork h✝ s c).ι = s'.ι\n⊢ ∀ (j : WalkingCospan), m ≫ c.π.app j = ... | apply PullbackCone.equalizer_ext
· simp only [liftPrecomp, Fork.ofι_pt, IsLimit.fac, PullbackCone.mk_π_app]
apply hs.hom_ext
apply Fork.equalizer_ext
simp only [Fork.ι_ofι, precompFork] at h
simp [c.condition, reassoc_of% h]
· simpa [liftPrecomp] using h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Preserves.Basic | {
"line": 309,
"column": 4
} | {
"line": 312,
"column": 33
} | [
{
"pp": "C : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\nJ : Type w\ninst✝¹ : Category.{w', w} J\nK₁ K₂ : J ⥤ C\nF : C ⥤ D\nh : K₁ ≅ K₂\ninst✝ : PreservesColimit K₁ F\nc : Cocone K₂\nt : IsColimit c\n⊢ IsColimit (F.mapCocone c)",
"usedConstants": [
"CategoryTheory... | apply IsColimit.precomposeHomEquiv (Functor.isoWhiskerRight h F :) _ _
have := (IsColimit.precomposeHomEquiv h c).symm t
apply IsColimit.ofIsoColimit (isColimitOfPreserves F this)
exact Cocone.ext (Iso.refl _) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Preserves.Basic | {
"line": 309,
"column": 4
} | {
"line": 312,
"column": 33
} | [
{
"pp": "C : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\nJ : Type w\ninst✝¹ : Category.{w', w} J\nK₁ K₂ : J ⥤ C\nF : C ⥤ D\nh : K₁ ≅ K₂\ninst✝ : PreservesColimit K₁ F\nc : Cocone K₂\nt : IsColimit c\n⊢ IsColimit (F.mapCocone c)",
"usedConstants": [
"CategoryTheory... | apply IsColimit.precomposeHomEquiv (Functor.isoWhiskerRight h F :) _ _
have := (IsColimit.precomposeHomEquiv h c).symm t
apply IsColimit.ofIsoColimit (isColimitOfPreserves F this)
exact Cocone.ext (Iso.refl _) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Preadditive.Basic | {
"line": 241,
"column": 12
} | {
"line": 241,
"column": 28
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Preadditive C\nX Y : C\nf : X ⟶ Y\nc : KernelFork f\nhc : IsLimit c\nh : IsZero c.pt\nP✝ : C\ng : P✝ ⟶ X\nhg : g ≫ f = 0\na : P✝ ⟶ c.pt\nha : a ≫ Fork.ι c = g\n⊢ a ≫ Fork.ι c = 0",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruc... | h.eq_of_tgt a 0, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | {
"line": 385,
"column": 2
} | {
"line": 387,
"column": 80
} | [
{
"pp": "C : Type u₁\ninst✝⁶ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝⁵ : Category.{v₂, u₂} D\ninst✝⁴ : HasZeroMorphisms C\ninst✝³ : HasZeroMorphisms D\nF : C ⥤ D\ninst✝² : F.PreservesZeroMorphisms\nJ : Type w₁\nf : J → C\ninst✝¹ : HasBiproduct f\ninst✝ : PreservesBiproduct f F\nW : C\ng : (j : J) → f j ⟶ W\n⊢ ... | ext j
dsimp only [Function.comp_def]
simp only [mapBiproduct_inv, ← Category.assoc, biproduct.ι_desc, ← F.map_comp] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | {
"line": 385,
"column": 2
} | {
"line": 387,
"column": 80
} | [
{
"pp": "C : Type u₁\ninst✝⁶ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝⁵ : Category.{v₂, u₂} D\ninst✝⁴ : HasZeroMorphisms C\ninst✝³ : HasZeroMorphisms D\nF : C ⥤ D\ninst✝² : F.PreservesZeroMorphisms\nJ : Type w₁\nf : J → C\ninst✝¹ : HasBiproduct f\ninst✝ : PreservesBiproduct f F\nW : C\ng : (j : J) → f j ⟶ W\n⊢ ... | ext j
dsimp only [Function.comp_def]
simp only [mapBiproduct_inv, ← Category.assoc, biproduct.ι_desc, ← F.map_comp] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | {
"line": 209,
"column": 42
} | {
"line": 209,
"column": 60
} | [
{
"pp": "C : Type u₁\nD : Type u₂\ninst✝⁴ : Category.{v₁, u₁} C\ninst✝³ : Category.{v₂, u₂} D\ninst✝² : Preadditive C\ninst✝¹ : Preadditive D\nF : C ⥤ D\ninst✝ : F.Additive\nJ : Type\nx✝ : Finite J\nval✝ : Fintype J\nf✝ : J → C\nb✝ : Bicone f✝\nhb : b✝.IsBilimit\n⊢ F.map (∑ a, b✝.π a ≫ b✝.ι a) = F.map (𝟙 b✝.pt... | IsBilimit.total hb | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 618,
"column": 14
} | {
"line": 618,
"column": 22
} | [
{
"pp": "case w.w.isTrue\nJ✝ : Type w\nC✝ : Type uC\ninst✝⁸ : Category.{uC', uC} C✝\ninst✝⁷ : HasZeroMorphisms C✝\nD : Type uD\ninst✝⁶ : Category.{uD', uD} D\ninst✝⁵ : HasZeroMorphisms D\nF : J✝ → C✝\nJ : Type w\nK : Type u_1\nC : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasZeroMorphisms C\nf g : J → C\nins... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 618,
"column": 14
} | {
"line": 618,
"column": 22
} | [
{
"pp": "case w.w.isTrue\nJ✝ : Type w\nC✝ : Type uC\ninst✝⁸ : Category.{uC', uC} C✝\ninst✝⁷ : HasZeroMorphisms C✝\nD : Type uD\ninst✝⁶ : Category.{uD', uD} D\ninst✝⁵ : HasZeroMorphisms D\nF : J✝ → C✝\nJ : Type w\nK : Type u_1\nC : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasZeroMorphisms C\nf g : J → C\nins... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 618,
"column": 14
} | {
"line": 618,
"column": 22
} | [
{
"pp": "case w.w.isTrue\nJ✝ : Type w\nC✝ : Type uC\ninst✝⁸ : Category.{uC', uC} C✝\ninst✝⁷ : HasZeroMorphisms C✝\nD : Type uD\ninst✝⁶ : Category.{uD', uD} D\ninst✝⁵ : HasZeroMorphisms D\nF : J✝ → C✝\nJ : Type w\nK : Type u_1\nC : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasZeroMorphisms C\nf g : J → C\nins... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 618,
"column": 14
} | {
"line": 618,
"column": 22
} | [
{
"pp": "case w.w.isFalse\nJ✝ : Type w\nC✝ : Type uC\ninst✝⁸ : Category.{uC', uC} C✝\ninst✝⁷ : HasZeroMorphisms C✝\nD : Type uD\ninst✝⁶ : Category.{uD', uD} D\ninst✝⁵ : HasZeroMorphisms D\nF : J✝ → C✝\nJ : Type w\nK : Type u_1\nC : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasZeroMorphisms C\nf g : J → C\nin... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 618,
"column": 14
} | {
"line": 618,
"column": 22
} | [
{
"pp": "case w.w.isFalse\nJ✝ : Type w\nC✝ : Type uC\ninst✝⁸ : Category.{uC', uC} C✝\ninst✝⁷ : HasZeroMorphisms C✝\nD : Type uD\ninst✝⁶ : Category.{uD', uD} D\ninst✝⁵ : HasZeroMorphisms D\nF : J✝ → C✝\nJ : Type w\nK : Type u_1\nC : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasZeroMorphisms C\nf g : J → C\nin... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 618,
"column": 14
} | {
"line": 618,
"column": 22
} | [
{
"pp": "case w.w.isFalse\nJ✝ : Type w\nC✝ : Type uC\ninst✝⁸ : Category.{uC', uC} C✝\ninst✝⁷ : HasZeroMorphisms C✝\nD : Type uD\ninst✝⁶ : Category.{uD', uD} D\ninst✝⁵ : HasZeroMorphisms D\nF : J✝ → C✝\nJ : Type w\nK : Type u_1\nC : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasZeroMorphisms C\nf g : J → C\nin... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 748,
"column": 8
} | {
"line": 748,
"column": 18
} | [
{
"pp": "case pos\nJ : Type w\nC : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasZeroMorphisms C\nf : J → C\ninst✝² : HasBiproduct f\np : J → Prop\ninst✝¹ : HasBiproduct (Subtype.restrict p f)\ninst✝ : DecidablePred p\nj : J\ni : Subtype p\nh : p j\n⊢ (if h : ↑i = j then eqToHom ⋯ else 0) =\n ι (Subtype.re... | dif_pos h, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 782,
"column": 8
} | {
"line": 782,
"column": 18
} | [
{
"pp": "case pos\nJ : Type w\nC : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasZeroMorphisms C\nf : J → C\ninst✝² : HasBiproduct f\np : J → Prop\ninst✝¹ : HasBiproduct (Subtype.restrict p f)\ninst✝ : DecidablePred p\nj : J\ni : Subtype p\nh : p j\n⊢ (if h : j = ↑i then eqToHom ⋯ else 0) =\n (if h : p j t... | dif_pos h, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 915,
"column": 10
} | {
"line": 915,
"column": 59
} | [
{
"pp": "case neg\nJ✝ : Type w\nC✝ : Type uC\ninst✝⁷ : Category.{uC', uC} C✝\ninst✝⁶ : HasZeroMorphisms C✝\nD : Type uD\ninst✝⁵ : Category.{uD', uD} D\ninst✝⁴ : HasZeroMorphisms D\nF : J✝ → C✝\nJ : Type w\nK✝ : Type u_1\nC : Type u\ninst✝³ : Category.{v, u} C\ninst✝² : HasZeroMorphisms C\nK : Type\ninst✝¹ : Fin... | replace w := w =≫ biproduct.π _ ⟨j, not_not.mp h⟩ | Lean.Elab.Tactic.evalReplace | Lean.Parser.Tactic.replace |
Mathlib.Algebra.Order.Antidiag.Finsupp | {
"line": 102,
"column": 10
} | {
"line": 104,
"column": 67
} | [
{
"pp": "case inl\nι : Type u_1\nμ : Type u_2\nμ' : Type u_3\ninst✝³ : DecidableEq ι\ninst✝² : AddCommMonoid μ\ninst✝¹ : HasAntidiagonal μ\ninst✝ : DecidableEq μ\ns✝ : Finset ι\nn✝ : μ\nf✝ : ι →₀ μ\ns : Finset ι\nn : μ\np : μ × μ\nx✝¹ x✝ : ↥(s.finsuppAntidiag p.2)\nf : ι →₀ μ\nhf✝ : f ∈ s.finsuppAntidiag p.2\ng... | · replace hf := mt (hf.2 ·) h
replace hg := mt (hg.2 ·) h
rw [notMem_support_iff.mp hf, notMem_support_iff.mp hg] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Order.Antidiag.Pi | {
"line": 122,
"column": 4
} | {
"line": 122,
"column": 12
} | [
{
"pp": "case refine_2.h\nι : Type u_1\nμ : Type u_2\nμ' : Type u_3\ninst✝³ : DecidableEq ι\ninst✝² : AddCommMonoid μ\ninst✝¹ : HasAntidiagonal μ\ninst✝ : DecidableEq μ\nn✝ : μ\ns : Finset ι\nn : μ\ne₁ e₂ : ↥s ≃ Fin #s\nf : ι → μ\ng : Fin #s → μ\nthis : ∑ x, g ((e₂.symm.trans e₁) x) = ∑ x, g x\n⊢ ∑ i, g i = n ∧... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Combinatorics.Enumerative.Composition | {
"line": 982,
"column": 2
} | {
"line": 983,
"column": 33
} | [
{
"pp": "n : ℕ\nc : Composition n\nd : CompositionAsSet n := c.toCompositionAsSet\nlength_eq : d.blocks.length = c.blocks.length\n⊢ d.blocks = c.blocks",
"usedConstants": [
"Nat.instMulZeroClass",
"List.eq_of_sum_take_eq",
"Composition.blocks",
"List.sum",
"Nat.instAddCancelCom... | suffices H : ∀ i ≤ d.blocks.length, (d.blocks.take i).sum = (c.blocks.take i).sum from
eq_of_sum_take_eq length_eq H | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSuffices__1 | Lean.Parser.Tactic.tacticSuffices_ |
Mathlib.Data.Fintype.Perm | {
"line": 69,
"column": 4
} | {
"line": 69,
"column": 41
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : DecidableEq α\na : α\nl : List α\nIH : ∀ {f : Equiv.Perm α}, (∀ (x : α), f x ≠ x → x ∈ l) → f ∈ permsOfList l\nf : Equiv.Perm α\nh✝ : ∀ (x : α), f x ≠ x → x ∈ a :: l\nhfa : ¬f a = a\nhfa' : f (f a) ≠ f a\nx : α\nhxa : x ≠ a\nh : f x = x\nh_1 : f x = a\nhx : ¬f a = x\n⊢ F... | exacts [hxa (h.symm.trans h_1), hx h] | Batteries.Tactic._aux_Batteries_Tactic_Init___elabRules_Batteries_Tactic_exacts_1 | Batteries.Tactic.exacts |
Mathlib.Data.Fintype.Perm | {
"line": 91,
"column": 14
} | {
"line": 91,
"column": 76
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\na : α\nl : List α\nf : Equiv.Perm α\nh✝ : f ∈ permsOfList (a :: l)\nx : α\nh : f ∈ flatMap (fun b ↦ List.map (fun f ↦ Equiv.swap a b * f) (permsOfList l)) l\nhx : f x ≠ x\ny : α\nhy : y ∈ l\nhy' : f ∈ List.map (fun f ↦ Equiv.swap a y * f) (permsOfList l)\ng : Equiv.... | split_ifs <;> [exact Ne.symm hxy; exact Ne.symm hxa; exact hx] | Batteries.Tactic._aux_Batteries_Tactic_SeqFocus___macroRules_Batteries_Tactic_seq_focus_1 | Batteries.Tactic.seq_focus |
Mathlib.GroupTheory.Perm.Support | {
"line": 596,
"column": 12
} | {
"line": 596,
"column": 35
} | [
{
"pp": "case neg.inl\nα : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nf : Perm α\nh : #f.support = 2\ny : α\nht : #{y} = 1\na : α\nha : ¬f a = a\nhmem : ¬a = y\nhins : {a, y} = f.support\nkey : ∀ (b : α), f b ≠ b ↔ b = a ∨ b = y\nha' : f a = a ∨ f a = y\n⊢ f a = (swap a y) a",
"usedConstants": [
... | Or.resolve_left ha' ha, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Finite | {
"line": 231,
"column": 2
} | {
"line": 235,
"column": 46
} | [
{
"pp": "α : Type u\ninst✝ : DecidableEq α\ng : Perm α\nu : Perm ↑(fixedPoints ⇑g)\n⊢ (ofSubtype u).Disjoint g",
"usedConstants": [
"Eq.mpr",
"MonoidHom.instFunLike",
"Equiv.instEquivLike",
"MonoidHom",
"Monoid.toMulOneClass",
"congrArg",
"Function.fixedPoints",
... | rw [disjoint_iff_eq_or_eq]
intro x
by_cases hx : x ∈ Function.fixedPoints g
· right; exact hx
· left; rw [ofSubtype_apply_of_not_mem u hx] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Finite | {
"line": 231,
"column": 2
} | {
"line": 235,
"column": 46
} | [
{
"pp": "α : Type u\ninst✝ : DecidableEq α\ng : Perm α\nu : Perm ↑(fixedPoints ⇑g)\n⊢ (ofSubtype u).Disjoint g",
"usedConstants": [
"Eq.mpr",
"MonoidHom.instFunLike",
"Equiv.instEquivLike",
"MonoidHom",
"Monoid.toMulOneClass",
"congrArg",
"Function.fixedPoints",
... | rw [disjoint_iff_eq_or_eq]
intro x
by_cases hx : x ∈ Function.fixedPoints g
· right; exact hx
· left; rw [ofSubtype_apply_of_not_mem u hx] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 192,
"column": 47
} | {
"line": 192,
"column": 63
} | [
{
"pp": "case h\nα : Type u_2\nf : Perm α\nx : α\ninst✝ : Finite α\nk : ℤ\nh₀ : 0 < ↑(orderOf f)\nh₁ : 0 ≤ k % ↑(orderOf f)\n⊢ (k % ↑(orderOf f)).natAbs < orderOf f ∧ (f ^ (k % ↑(orderOf f))) x = (f ^ k) x",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"zpow_mod_orderOf",
"con... | zpow_mod_orderOf | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 267,
"column": 2
} | {
"line": 267,
"column": 34
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ng : Perm α\np : β → Prop\ninst✝ : DecidablePred p\nf : α ≃ Subtype p\na : α\nha : g a ≠ a\nha' : ∀ ⦃y : α⦄, g y ≠ y → g.SameCycle a y\n⊢ (g.extendDomain f).IsCycle",
"usedConstants": [
"Equiv.instEquivLike",
"Equiv.Perm.extendDomain",
"Equiv",
"Su... | refine ⟨f a, ?_, fun b hb => ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 269,
"column": 4
} | {
"line": 269,
"column": 54
} | [
{
"pp": "case refine_1\nα : Type u_2\nβ : Type u_3\ng : Perm α\np : β → Prop\ninst✝ : DecidablePred p\nf : α ≃ Subtype p\na : α\nha : g a ≠ a\nha' : ∀ ⦃y : α⦄, g y ≠ y → g.SameCycle a y\n⊢ ↑(f (g a)) ≠ ↑(f a)",
"usedConstants": [
"Equiv.instEquivLike",
"Function.Injective.ne",
"Equiv",
... | exact Subtype.coe_injective.ne (f.injective.ne ha) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 270,
"column": 2
} | {
"line": 271,
"column": 41
} | [
{
"pp": "case refine_2\nα : Type u_2\nβ : Type u_3\ng : Perm α\np : β → Prop\ninst✝ : DecidablePred p\nf : α ≃ Subtype p\na : α\nha : g a ≠ a\nha' : ∀ ⦃y : α⦄, g y ≠ y → g.SameCycle a y\nb : β\nhb : (g.extendDomain f) b ≠ b\n⊢ (g.extendDomain f).SameCycle (↑(f a)) b",
"usedConstants": [
"Subtype.coe_m... | have h : b = f (f.symm ⟨b, of_not_not <| hb ∘ extendDomain_apply_not_subtype _ _⟩) := by
rw [apply_symm_apply, Subtype.coe_mk] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 295,
"column": 56
} | {
"line": 295,
"column": 72
} | [
{
"pp": "α : Type u_2\nf : Perm α\nx y : α\ninst✝ : Finite α\nhf : f.IsCycle\nhx : f x ≠ x\nhy : f y ≠ y\nn : ℤ\nhn : (f ^ n) x = y\nthis : 0 ≤ n % ↑(orderOf f)\n⊢ (f ^ (n % ↑(orderOf f))) x = y",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"zpow_mod_orderOf",
"congrArg",
... | zpow_mod_orderOf | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 347,
"column": 8
} | {
"line": 347,
"column": 36
} | [
{
"pp": "case right\nι : Type u_1\nα : Type u_2\nβ : Type u_3\nf g : Perm α\nx y : α\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nσ : Perm α\nhσ : σ.IsCycle\nn : ℤ\nhy✝ : (σ ^ n) (Classical.choose hσ) ∈ σ.support\nhy : σ ((σ ^ n) (Classical.choose hσ)) ≠ (σ ^ n) (Classical.choose hσ)\n⊢ ∃ a, (fun τ ↦ ⟨↑τ (Classi... | exact ⟨⟨σ ^ n, n, rfl⟩, rfl⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.GroupTheory.Perm.Sign | {
"line": 351,
"column": 4
} | {
"line": 351,
"column": 58
} | [
{
"pp": "case h\nα : Type u\ninst✝³ : DecidableEq α\nβ : Type v\ninst✝² : Finite α\ninst✝¹ : DecidableEq β\ninst✝ : Finite β\nf : Perm α\ne : α ≃ β\na✝ : List β\nb✝ : List α\nhs : ∀ (x : α), x ∈ ⟦b✝⟧\nht : ∀ (x : β), x ∈ ⟦a✝⟧\nn : ℕ\ne' : β ≃ Fin n\n⊢ signAux ((e'.symm.trans ((e.symm.trans f).trans e)).trans e'... | ← signAux_eq_signAux2 _ _ (e.trans e') fun _ _ => hs _ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Sign | {
"line": 445,
"column": 30
} | {
"line": 445,
"column": 38
} | [
{
"pp": "α : Type u\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\ns : Perm α →* ℤˣ\nhs : Surjective ⇑s\nf : Perm α\nx✝ : f.IsSwap\nx y : α\nhxy : x ≠ y\nhxy' : f = swap x y\nh : ¬s (swap x y) = -1\nthis✝¹ : ∀ (f : Perm α), f.IsSwap → s f = 1\ng : Perm α\nhg : s g = -1\nl : List (Perm α)\nhl : l.prod = g ∧ ∀ g ∈ l... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.GroupTheory.Perm.Sign | {
"line": 445,
"column": 30
} | {
"line": 445,
"column": 38
} | [
{
"pp": "α : Type u\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\ns : Perm α →* ℤˣ\nhs : Surjective ⇑s\nf : Perm α\nx✝ : f.IsSwap\nx y : α\nhxy : x ≠ y\nhxy' : f = swap x y\nh : ¬s (swap x y) = -1\nthis✝¹ : ∀ (f : Perm α), f.IsSwap → s f = 1\ng : Perm α\nhg : s g = -1\nl : List (Perm α)\nhl : l.prod = g ∧ ∀ g ∈ l... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Sign | {
"line": 445,
"column": 30
} | {
"line": 445,
"column": 38
} | [
{
"pp": "α : Type u\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\ns : Perm α →* ℤˣ\nhs : Surjective ⇑s\nf : Perm α\nx✝ : f.IsSwap\nx y : α\nhxy : x ≠ y\nhxy' : f = swap x y\nh : ¬s (swap x y) = -1\nthis✝¹ : ∀ (f : Perm α), f.IsSwap → s f = 1\ng : Perm α\nhg : s g = -1\nl : List (Perm α)\nhl : l.prod = g ∧ ∀ g ∈ l... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Sign | {
"line": 565,
"column": 4
} | {
"line": 565,
"column": 45
} | [
{
"pp": "case right\nα : Type u\ninst✝³ : DecidableEq α\nβ : Type v\ninst✝² : Fintype α\ninst✝¹ : DecidableEq β\ninst✝ : Fintype β\nσa : Perm α\nσb : Perm β\n⊢ sign (sumCongr 1 σb) = sign σb",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"MulOne.toOne",
"instFintypeSum",
"MonoidHom.... | induction σb using swap_induction_on with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 595,
"column": 4
} | {
"line": 608,
"column": 21
} | [
{
"pp": "case intro.mpr\nβ : Type u_3\ninst✝ : Finite β\nf : Perm β\nhf : f.IsCycle\na b : ℕ\nval✝ : Fintype β\n⊢ (∃ x, f x ≠ x ∧ (f ^ a) x = (f ^ b) x) → f ^ a = f ^ b",
"usedConstants": [
"zpow_natCast",
"Eq.mpr",
"Equiv.Perm.support",
"Equiv.Perm.notMem_support",
"InvOneClas... | · rintro ⟨x, hx, hx'⟩
wlog hab : a ≤ b generalizing a b
· exact (this hx'.symm (le_of_not_ge hab)).symm
suffices f ^ (b - a) = 1 by
rw [pow_sub _ hab, mul_inv_eq_one] at this
rw [this]
rw [hf.pow_eq_one_iff]
by_cases hfa : (f ^ a) x ∈ f.support
· refine ⟨(f ^ a) x, me... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 698,
"column": 4
} | {
"line": 698,
"column": 50
} | [
{
"pp": "case inl.inr\nα : Type u_2\ninst✝ : DecidableEq α\nx y : α\nhab : x ≠ y\n⊢ (swap x y).SameCycle x y",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"congrArg",
"Equiv.swap",
"DivInvMonoid.toZPow",
"zpow_one",
"id",
"Int",
"Group.toDivInvMo... | · exact ⟨1, by rw [zpow_one, swap_apply_left]⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 768,
"column": 25
} | {
"line": 768,
"column": 46
} | [
{
"pp": "α : Type u_2\nf : Perm α\na : α\ns : Finset α\nhf : f.IsCycleOn ↑s\nha : a ∈ s\nm n : ℕ\n⊢ (f ^ m) a = (f ^ n) a ↔ ↑(#s) ∣ ↑n - ↑m",
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"Equiv.instEquivLike",
"congrArg",
"HSub.hSub",
"Equiv.Perm.instPowNat",
"DivInvMono... | ← hf.zpow_apply_eq ha | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 773,
"column": 25
} | {
"line": 773,
"column": 46
} | [
{
"pp": "α : Type u_2\nf : Perm α\na : α\ns : Finset α\nhf : f.IsCycleOn ↑s\nha : a ∈ s\nm n : ℤ\n⊢ (f ^ m) a = (f ^ n) a ↔ ↑(#s) ∣ n - m",
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"Equiv.instEquivLike",
"congrArg",
"HSub.hSub",
"DivInvMonoid.toZPow",
"id",
"In... | ← hf.zpow_apply_eq ha | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 262,
"column": 32
} | {
"line": 262,
"column": 88
} | [
{
"pp": "α : Type u_2\nf : Perm α\nx : α\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nh : f x ≠ x\n⊢ 2 ≤ #(f.cycleOf x).support",
"usedConstants": [
"Equiv.Perm.instDecidableRelSameCycle",
"Equiv.Perm.isCycle_cycleOf",
"Equiv.Perm.IsCycle.two_le_card_support",
"Equiv.Perm.cycleOf"
... | by simpa using (isCycle_cycleOf _ h).two_le_card_support | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 403,
"column": 8
} | {
"line": 403,
"column": 28
} | [
{
"pp": "ι : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nl✝¹ : List α\nf : Perm α\nh : ∀ {x : α}, f x ≠ x → x ∈ l✝¹\nl✝ : List α\ng : Perm α\nhfg : ∀ {x : α}, g x ≠ x → f.cycleOf x = g.cycleOf x\nx : α\nl : List α\nhg : ∀ {x_1 : α}, g x_1 ≠ x_1 → x_1 ∈ x :: l\nhx : ¬g x = x\... | rw [hfg hx] at hm₁ ⊢ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Perm.Fin | {
"line": 115,
"column": 2
} | {
"line": 124,
"column": 46
} | [
{
"pp": "n : ℕ\n⊢ (finRotate (n + 2)).IsCycle",
"usedConstants": [
"zpow_natCast",
"Eq.mpr",
"instNeZeroNatHAdd_1",
"MulOne.toOne",
"False",
"Fin.ext_iff",
"Nat.recAux",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Equiv.instEquivLike",
"HMul.... | refine ⟨0, by simp, fun x hx' => ⟨x, ?_⟩⟩
clear hx'
obtain ⟨x, hx⟩ := x
rw [zpow_natCast, Fin.ext_iff, Fin.val_mk]
induction x with
| zero => rfl
| succ x ih =>
rw [pow_succ', Perm.mul_apply, coe_finRotate_of_ne_last, ih (lt_trans x.lt_succ_self hx)]
rw [Ne, Fin.ext_iff, ih (lt_trans x.lt_succ_self ... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Fin | {
"line": 115,
"column": 2
} | {
"line": 124,
"column": 46
} | [
{
"pp": "n : ℕ\n⊢ (finRotate (n + 2)).IsCycle",
"usedConstants": [
"zpow_natCast",
"Eq.mpr",
"instNeZeroNatHAdd_1",
"MulOne.toOne",
"False",
"Fin.ext_iff",
"Nat.recAux",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Equiv.instEquivLike",
"HMul.... | refine ⟨0, by simp, fun x hx' => ⟨x, ?_⟩⟩
clear hx'
obtain ⟨x, hx⟩ := x
rw [zpow_natCast, Fin.ext_iff, Fin.val_mk]
induction x with
| zero => rfl
| succ x ih =>
rw [pow_succ', Perm.mul_apply, coe_finRotate_of_ne_last, ih (lt_trans x.lt_succ_self hx)]
rw [Ne, Fin.ext_iff, ih (lt_trans x.lt_succ_self ... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Fin | {
"line": 127,
"column": 2
} | {
"line": 129,
"column": 25
} | [
{
"pp": "n : ℕ\nh : 2 ≤ n\n⊢ (finRotate n).IsCycle",
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"congrArg",
"Exists",
"id",
"instOfNatNat",
"LE.le",
"instLENat",
"CanonicallyOrderedAdd.toExistsAddOfLE",
"finRotate",
"add_co... | obtain ⟨m, rfl⟩ := exists_add_of_le h
rw [add_comm]
exact isCycle_finRotate | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Fin | {
"line": 127,
"column": 2
} | {
"line": 129,
"column": 25
} | [
{
"pp": "n : ℕ\nh : 2 ≤ n\n⊢ (finRotate n).IsCycle",
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"congrArg",
"Exists",
"id",
"instOfNatNat",
"LE.le",
"instLENat",
"CanonicallyOrderedAdd.toExistsAddOfLE",
"finRotate",
"add_co... | obtain ⟨m, rfl⟩ := exists_add_of_le h
rw [add_comm]
exact isCycle_finRotate | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 551,
"column": 58
} | {
"line": 566,
"column": 19
} | [
{
"pp": "α : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nf : Perm α\nx : α\n⊢ f.cycleOf x ∈ f.cycleFactorsFinset ↔ x ∈ f.support",
"usedConstants": [
"Equiv.Perm.instDecidableRelSameCycle",
"Eq.mpr",
"Equiv.Perm.support",
"False",
"Equiv.Perm.isCycle_cycleOf",
"E... | by
rw [mem_cycleFactorsFinset_iff]
constructor
· rintro ⟨hc, _⟩
contrapose hc
rw [notMem_support, ← cycleOf_eq_one_iff] at hc
simp [hc]
· intro hx
refine ⟨isCycle_cycleOf _ (mem_support.mp hx), ?_⟩
intro y hy
rw [mem_support] at hy
rw [cycleOf_apply]
split_ifs with H
· rfl
... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 745,
"column": 2
} | {
"line": 745,
"column": 10
} | [
{
"pp": "case a\nα : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\ng✝ k✝ c✝ g k c : Perm α\nhc : ∀ a ∈ c.support, c a = g a\na : α\nha : a ∈ (k * c * k⁻¹).support\n⊢ k⁻¹ a ∈ c.support",
"usedConstants": [
"Equiv.Perm.support",
"False",
"Equiv.instEquivLike",
"HMul.hMul",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 833,
"column": 10
} | {
"line": 835,
"column": 25
} | [
{
"pp": "case neg\nα : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\ng f✝ σ τ : Perm α\nhd : σ.Disjoint τ\na✝ : σ.IsCycle\nhσ : ∀ {f : Perm α}, f ∈ σ.cycleFactorsFinset → (σ * f⁻¹).cycleFactorsFinset = σ.cycleFactorsFinset \\ {f}\nhτ : ∀ {f : Perm α}, f ∈ τ.cycleFactorsFinset → (τ * f⁻¹).cycleFactorsFins... | · rw [mul_apply]
rw [← hf.right _ (mem_support.mpr hfx)] at hx
contradiction | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 825,
"column": 6
} | {
"line": 835,
"column": 25
} | [
{
"pp": "case refine_3.inl\nα : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\ng f✝ σ τ : Perm α\nhd : σ.Disjoint τ\na✝ : σ.IsCycle\nhσ : ∀ {f : Perm α}, f ∈ σ.cycleFactorsFinset → (σ * f⁻¹).cycleFactorsFinset = σ.cycleFactorsFinset \\ {f}\nhτ : ∀ {f : Perm α}, f ∈ τ.cycleFactorsFinset → (τ * f⁻¹).cycleFa... | · rw [mem_cycleFactorsFinset_iff] at hf
intro x
rcases hd.symm x with hx | hx
· exact Or.inl hx
· refine Or.inr ?_
by_cases hfx : f x = x
· rw [← hfx]
simpa [hx] using hfx.symm
· rw [mul_apply]
rw [← hf.right _ (mem_support.mpr hfx)] ... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.GroupTheory.Perm.Cycle.Type | {
"line": 514,
"column": 67
} | {
"line": 514,
"column": 76
} | [
{
"pp": "G : Type u_3\ninst✝¹ : Group G\ninst✝ : Fintype G\np : ℕ\nhp : Fact (Nat.Prime p)\nhdvd : p ∣ Fintype.card G\nhp' : p - 1 ≠ 0\nScard : p ∣ Fintype.card ↑(vectorsProdEqOne G p)\nf : ℕ → ↑(vectorsProdEqOne G p) → ↑(vectorsProdEqOne G p) := fun k v ↦ VectorsProdEqOne.rotate v k\nhf1 : ∀ (v : ↑(vectorsProd... | ← hf2 1 k | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 848,
"column": 10
} | {
"line": 850,
"column": 25
} | [
{
"pp": "case neg\nα : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\ng f✝ σ τ : Perm α\nhd : σ.Disjoint τ\na✝ : σ.IsCycle\nhσ : ∀ {f : Perm α}, f ∈ σ.cycleFactorsFinset → (σ * f⁻¹).cycleFactorsFinset = σ.cycleFactorsFinset \\ {f}\nhτ : ∀ {f : Perm α}, f ∈ τ.cycleFactorsFinset → (τ * f⁻¹).cycleFactorsFins... | · rw [mul_apply]
rw [← hf.right _ (mem_support.mpr hfx)] at hx
contradiction | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.LinearAlgebra.Multilinear.DFinsupp | {
"line": 214,
"column": 5
} | {
"line": 214,
"column": 21
} | [
{
"pp": "ι : Type uι\nκ : ι → Type uκ\nS : Type uS\nR : Type uR\nM : (i : ι) → κ i → Type uM\nN✝ : ((i : ι) → κ i) → Type uN\ninst✝⁹ : DecidableEq ι\ninst✝⁸ : Fintype ι\ninst✝⁷ : CommSemiring R\ninst✝⁶ : (i : ι) → (k : κ i) → AddCommMonoid (M i k)\ninst✝⁵ : (p : (i : ι) → κ i) → AddCommMonoid (N✝ p)\ninst✝⁴ : (... | by ext f x; simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.LinearAlgebra.Matrix.SemiringInverse | {
"line": 119,
"column": 2
} | {
"line": 119,
"column": 83
} | [
{
"pp": "n : Type u_1\nR : Type u_3\ninst✝² : Fintype n\ninst✝¹ : DecidableEq n\ninst✝ : CommSemiring R\nA : Matrix n n R\ni j : n\nh : i ≠ j\n⊢ ∑ x ∈ univ.sigma fun a ↦ {x ∈ ofSign 1 | x j = a}, A i x.fst * ∏ k ∈ {j}ᶜ, A k (x.snd k) =\n ∑ x ∈ univ.sigma fun a ↦ {x ∈ ofSign (-1) | x j = a}, A i x.fst * ∏ k ∈... | let f : (Σ x : n, Perm n) → (Σ x : n, Perm n) := fun ⟨x, σ⟩ ↦ ⟨σ i, σ * swap i j⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.LinearAlgebra.Multilinear.Basic | {
"line": 458,
"column": 65
} | {
"line": 458,
"column": 70
} | [
{
"pp": "R : Type uR\nι : Type uι\nM₁ : ι → Type v₁\nM₂ : Type v₂\ninst✝⁵ : Semiring R\ninst✝⁴ : (i : ι) → AddCommMonoid (M₁ i)\ninst✝³ : AddCommMonoid M₂\ninst✝² : (i : ι) → Module R (M₁ i)\ninst✝¹ : Module R M₂\nf : MultilinearMap R M₁ M₂\ninst✝ : DecidableEq ι\nm : (i : ι) → M₁ i\nt✝ : Finset ι\ni : ι\nt : F... | Hrec, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.Multilinear.Basic | {
"line": 458,
"column": 71
} | {
"line": 458,
"column": 76
} | [
{
"pp": "R : Type uR\nι : Type uι\nM₁ : ι → Type v₁\nM₂ : Type v₂\ninst✝⁵ : Semiring R\ninst✝⁴ : (i : ι) → AddCommMonoid (M₁ i)\ninst✝³ : AddCommMonoid M₂\ninst✝² : (i : ι) → Module R (M₁ i)\ninst✝¹ : Module R M₂\nf : MultilinearMap R M₁ M₂\ninst✝ : DecidableEq ι\nm : (i : ι) → M₁ i\nt✝ : Finset ι\ni : ι\nt : F... | Hrec, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.BrauerGroup.Defs | {
"line": 76,
"column": 26
} | {
"line": 76,
"column": 34
} | [
{
"pp": "K : Type u\ninst✝ : Field K\nA : CSA K\nB : CSA K\nC : CSA K\nn m : ℕ\nhn : n ≠ 0\nhm : m ≠ 0\niso1 : Matrix (Fin n) (Fin n) ↑A.toAlgCat ≃ₐ[K] Matrix (Fin m) (Fin m) ↑B.toAlgCat\np q : ℕ\nhp : p ≠ 0\nhq : q ≠ 0\niso2 : Matrix (Fin p) (Fin p) ↑B.toAlgCat ≃ₐ[K] Matrix (Fin q) (Fin q) ↑C.toAlgCat\n⊢ p * n... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.BrauerGroup.Defs | {
"line": 76,
"column": 26
} | {
"line": 76,
"column": 34
} | [
{
"pp": "K : Type u\ninst✝ : Field K\nA : CSA K\nB : CSA K\nC : CSA K\nn m : ℕ\nhn : n ≠ 0\nhm : m ≠ 0\niso1 : Matrix (Fin n) (Fin n) ↑A.toAlgCat ≃ₐ[K] Matrix (Fin m) (Fin m) ↑B.toAlgCat\np q : ℕ\nhp : p ≠ 0\nhq : q ≠ 0\niso2 : Matrix (Fin p) (Fin p) ↑B.toAlgCat ≃ₐ[K] Matrix (Fin q) (Fin q) ↑C.toAlgCat\n⊢ p * n... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BrauerGroup.Defs | {
"line": 76,
"column": 26
} | {
"line": 76,
"column": 34
} | [
{
"pp": "K : Type u\ninst✝ : Field K\nA : CSA K\nB : CSA K\nC : CSA K\nn m : ℕ\nhn : n ≠ 0\nhm : m ≠ 0\niso1 : Matrix (Fin n) (Fin n) ↑A.toAlgCat ≃ₐ[K] Matrix (Fin m) (Fin m) ↑B.toAlgCat\np q : ℕ\nhp : p ≠ 0\nhq : q ≠ 0\niso2 : Matrix (Fin p) (Fin p) ↑B.toAlgCat ≃ₐ[K] Matrix (Fin q) (Fin q) ↑C.toAlgCat\n⊢ p * n... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BrauerGroup.Defs | {
"line": 76,
"column": 39
} | {
"line": 76,
"column": 47
} | [
{
"pp": "K : Type u\ninst✝ : Field K\nA : CSA K\nB : CSA K\nC : CSA K\nn m : ℕ\nhn : n ≠ 0\nhm : m ≠ 0\niso1 : Matrix (Fin n) (Fin n) ↑A.toAlgCat ≃ₐ[K] Matrix (Fin m) (Fin m) ↑B.toAlgCat\np q : ℕ\nhp : p ≠ 0\nhq : q ≠ 0\niso2 : Matrix (Fin p) (Fin p) ↑B.toAlgCat ≃ₐ[K] Matrix (Fin q) (Fin q) ↑C.toAlgCat\n⊢ m * q... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.BrauerGroup.Defs | {
"line": 76,
"column": 39
} | {
"line": 76,
"column": 47
} | [
{
"pp": "K : Type u\ninst✝ : Field K\nA : CSA K\nB : CSA K\nC : CSA K\nn m : ℕ\nhn : n ≠ 0\nhm : m ≠ 0\niso1 : Matrix (Fin n) (Fin n) ↑A.toAlgCat ≃ₐ[K] Matrix (Fin m) (Fin m) ↑B.toAlgCat\np q : ℕ\nhp : p ≠ 0\nhq : q ≠ 0\niso2 : Matrix (Fin p) (Fin p) ↑B.toAlgCat ≃ₐ[K] Matrix (Fin q) (Fin q) ↑C.toAlgCat\n⊢ m * q... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BrauerGroup.Defs | {
"line": 76,
"column": 39
} | {
"line": 76,
"column": 47
} | [
{
"pp": "K : Type u\ninst✝ : Field K\nA : CSA K\nB : CSA K\nC : CSA K\nn m : ℕ\nhn : n ≠ 0\nhm : m ≠ 0\niso1 : Matrix (Fin n) (Fin n) ↑A.toAlgCat ≃ₐ[K] Matrix (Fin m) (Fin m) ↑B.toAlgCat\np q : ℕ\nhp : p ≠ 0\nhq : q ≠ 0\niso2 : Matrix (Fin p) (Fin p) ↑B.toAlgCat ≃ₐ[K] Matrix (Fin q) (Fin q) ↑C.toAlgCat\n⊢ m * q... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 513,
"column": 32
} | {
"line": 513,
"column": 50
} | [
{
"pp": "n : Type u_2\ninst✝³ : DecidableEq n\ninst✝² : Fintype n\nR : Type v\ninst✝¹ : CommRing R\ninst✝ : Nontrivial n\nu v : n → R\ni j : n\nhij : i ≠ j\nuv' : Matrix n n R := ((vecMulVec u v).updateRow i v).updateRow j v\nhuv' : uv'.det = 0\nthis : vecMulVec u v = (uv'.updateRow i (u i • uv' i)).updateRow j... | updateRow_eq_self, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 513,
"column": 71
} | {
"line": 513,
"column": 89
} | [
{
"pp": "n : Type u_2\ninst✝³ : DecidableEq n\ninst✝² : Fintype n\nR : Type v\ninst✝¹ : CommRing R\ninst✝ : Nontrivial n\nu v : n → R\ni j : n\nhij : i ≠ j\nuv' : Matrix n n R := ((vecMulVec u v).updateRow i v).updateRow j v\nhuv' : uv'.det = 0\nthis : vecMulVec u v = (uv'.updateRow i (u i • uv' i)).updateRow j... | updateRow_eq_self, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Types.Limits | {
"line": 117,
"column": 2
} | {
"line": 117,
"column": 10
} | [
{
"pp": "J : Type v\ninst✝¹ : Category.{w, v} J\nF : J ⥤ Type u\ninst✝ : Small.{u, max u v} ↑F.sections\nx y : (limitCone F).pt\nw : (equivShrink ↑F.sections).symm x = (equivShrink ↑F.sections).symm y\n⊢ x = y",
"usedConstants": [
"Equiv.instEquivLike",
"CategoryTheory.Limits.Types.Small.limitCo... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.CategoryTheory.Limits.Types.Limits | {
"line": 117,
"column": 2
} | {
"line": 117,
"column": 10
} | [
{
"pp": "J : Type v\ninst✝¹ : Category.{w, v} J\nF : J ⥤ Type u\ninst✝ : Small.{u, max u v} ↑F.sections\nx y : (limitCone F).pt\nw : (equivShrink ↑F.sections).symm x = (equivShrink ↑F.sections).symm y\n⊢ x = y",
"usedConstants": [
"Equiv.instEquivLike",
"CategoryTheory.Limits.Types.Small.limitCo... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Types.Limits | {
"line": 117,
"column": 2
} | {
"line": 117,
"column": 10
} | [
{
"pp": "J : Type v\ninst✝¹ : Category.{w, v} J\nF : J ⥤ Type u\ninst✝ : Small.{u, max u v} ↑F.sections\nx y : (limitCone F).pt\nw : (equivShrink ↑F.sections).symm x = (equivShrink ↑F.sections).symm y\n⊢ x = y",
"usedConstants": [
"Equiv.instEquivLike",
"CategoryTheory.Limits.Types.Small.limitCo... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Types.Limits | {
"line": 116,
"column": 87
} | {
"line": 117,
"column": 10
} | [
{
"pp": "J : Type v\ninst✝¹ : Category.{w, v} J\nF : J ⥤ Type u\ninst✝ : Small.{u, max u v} ↑F.sections\nx y : (limitCone F).pt\nw : (equivShrink ↑F.sections).symm x = (equivShrink ↑F.sections).symm y\n⊢ x = y",
"usedConstants": [
"Equiv.instEquivLike",
"CategoryTheory.Limits.Types.Small.limitCo... | by
simp_all | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Types.Limits | {
"line": 211,
"column": 15
} | {
"line": 211,
"column": 83
} | [
{
"pp": "J : Type v\ninst✝¹ : Category.{w, v} J\nF : J ⥤ Type u\ninst✝ : HasLimit F\nX✝ Y✝ : J ⥤ Type (max u v)\nf : X✝ ⟶ Y✝\n⊢ lim.map f ≫ ((fun F ↦ (limitEquivSections F).toIso) Y✝).hom =\n ((fun F ↦ (limitEquivSections F).toIso) X✝).hom ≫ (Functor.sectionsFunctor J).map f",
"usedConstants": [
"C... | ext x; exact Subtype.ext (funext fun j ↦ congr_hom (limMap_π f j) x) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Types.Limits | {
"line": 211,
"column": 15
} | {
"line": 211,
"column": 83
} | [
{
"pp": "J : Type v\ninst✝¹ : Category.{w, v} J\nF : J ⥤ Type u\ninst✝ : HasLimit F\nX✝ Y✝ : J ⥤ Type (max u v)\nf : X✝ ⟶ Y✝\n⊢ lim.map f ≫ ((fun F ↦ (limitEquivSections F).toIso) Y✝).hom =\n ((fun F ↦ (limitEquivSections F).toIso) X✝).hom ≫ (Functor.sectionsFunctor J).map f",
"usedConstants": [
"C... | ext x; exact Subtype.ext (funext fun j ↦ congr_hom (limMap_π f j) x) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Types.ColimitType | {
"line": 229,
"column": 4
} | {
"line": 229,
"column": 61
} | [
{
"pp": "J : Type u\ninst✝ : Category.{v, u} J\nF : J ⥤ Type w₀\nc : F.CoconeTypes\nhc : c.IsColimit\nc' : F.CoconeTypes\ne : c.pt ≃ c'.pt\nhe : ∀ (j : J) (x : F.obj j), c'.ι j x = e (c.ι j x)\n⊢ Function.Bijective (F.descColimitType c')",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
... | convert! Function.Bijective.comp e.bijective hc.bijective | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___macroRules_Mathlib_Tactic_convert!_1 | Mathlib.Tactic.convert! |
Mathlib.CategoryTheory.Limits.Types.ColimitType | {
"line": 232,
"column": 4
} | {
"line": 232,
"column": 12
} | [
{
"pp": "case h.e'_3.h\nJ : Type u\ninst✝ : Category.{v, u} J\nF : J ⥤ Type w₀\nc : F.CoconeTypes\nhc : c.IsColimit\nc' : F.CoconeTypes\ne : c.pt ≃ c'.pt\nhe : ∀ (j : J) (x : F.obj j), c'.ι j x = e (c.ι j x)\nj : J\nx : F.obj j\n⊢ F.descColimitType c' (F.ιColimitType j x) = (⇑e ∘ F.descColimitType c) (F.ιColimi... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.LinearAlgebra.Multilinear.Basic | {
"line": 1106,
"column": 4
} | {
"line": 1114,
"column": 44
} | [
{
"pp": "R : Type uR\nS : Type uS\nι : Type uι\nn : ℕ\nM : Fin n.succ → Type v\nM₁ : ι → Type v₁\nM₁' : ι → Type v₁'\nM₁'' : ι → Type v₁''\nM₂ : Type v₂\nM₃ : Type v₃\nM₄ : Type v₄\nM' : Type v'\ninst✝⁸ : CommSemiring R\ninst✝⁷ : (i : ι) → AddCommMonoid (M₁ i)\ninst✝⁶ : (i : Fin n.succ) → AddCommMonoid (M i)\ni... | intro _ f i f₁ f₂
ext g x
change (g fun j ↦ update f i (f₁ + f₂) j <| x j) =
(g fun j ↦ update f i f₁ j <| x j) + g fun j ↦ update f i f₂ j (x j)
let c : Π (i : ι), (M₁ i →ₗ[R] M₁' i) → M₁' i := fun i f ↦ f (x i)
convert! g.map_update_add (fun j ↦ f j (x j)) i (f₁ (x i)) (f₂ (x i)) with j j j
... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.