module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 365
values | kind stringclasses 368
values |
|---|---|---|---|---|---|---|
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 458,
"column": 6
} | {
"line": 458,
"column": 37
} | [
{
"pp": "case invFun.fst\nC : Type u\ninst✝³ : Category.{v, u} C\nD : Type u'\ninst✝² : Category.{v', u'} D\ninst✝¹ : HasZeroMorphisms C\ninst✝ : HasZeroObject C\nX Y : C\nhX : 𝟙 X = 0\nhY : 𝟙 Y = 0\n⊢ X ≅ 0",
"usedConstants": [
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
... | exact (idZeroEquivIsoZero X) hX | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 458,
"column": 6
} | {
"line": 458,
"column": 37
} | [
{
"pp": "case invFun.fst\nC : Type u\ninst✝³ : Category.{v, u} C\nD : Type u'\ninst✝² : Category.{v', u'} D\ninst✝¹ : HasZeroMorphisms C\ninst✝ : HasZeroObject C\nX Y : C\nhX : 𝟙 X = 0\nhY : 𝟙 Y = 0\n⊢ X ≅ 0",
"usedConstants": [
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
... | exact (idZeroEquivIsoZero X) hX | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Preserves.Basic | {
"line": 244,
"column": 8
} | {
"line": 244,
"column": 38
} | [
{
"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\nJ' : Type w₂\ninst✝¹ : Category.{w₂', w₂} J'\ne : J ≌ J'\nF : C ⥤ D\ninst✝ : PreservesLimitsOfShape J F\nK : J' ⥤ C\nc : Cone K\nt : IsLimit c\nequ : e.inverse ⋙ e.functor ⋙ K ... | simp [equ, ← Functor.map_comp] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Preserves.Basic | {
"line": 303,
"column": 8
} | {
"line": 303,
"column": 38
} | [
{
"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\nJ' : Type w₂\ninst✝¹ : Category.{w₂', w₂} J'\ne : J ≌ J'\nF : C ⥤ D\ninst✝ : PreservesColimitsOfShape J F\nK : J' ⥤ C\nc : Cocone K\nt : IsColimit c\nequ : e.inverse ⋙ e.functo... | simp [equ, ← Functor.map_comp] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {
"line": 754,
"column": 30
} | {
"line": 754,
"column": 70
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\nD : Type u'\ninst✝² : Category.{v', u'} D\ninst✝¹ : HasZeroMorphisms C\nX Y : C\ninst✝ : HasBinaryProduct X Y\nZ✝ : C\nx✝¹ x✝ : Z✝ ⟶ Y\ne : x✝¹ ≫ prod.inr X Y = x✝ ≫ prod.inr X Y\n⊢ x✝¹ = x✝",
"usedConstants": [
"CategoryTheory.Category.assoc",
"C... | by simpa using congrArg (· ≫ prod.snd) e | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 220,
"column": 4
} | {
"line": 220,
"column": 42
} | [
{
"pp": "case h_obj\nT : Type u₁\ninst✝ : Category.{v₁, u₁} T\nY : T\nx : Over Y\n⊢ (map (𝟙 Y)).obj x = (𝟭 (Over Y)).obj x",
"usedConstants": [
"CategoryTheory.Over.map",
"CategoryTheory.Over",
"CategoryTheory.Functor.id",
"CategoryTheory.CategoryStruct.id",
"id",
"Cate... | dsimp [Over, Over.map, Comma.mapRight] | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 224,
"column": 4
} | {
"line": 224,
"column": 42
} | [
{
"pp": "case h_map\nT : Type u₁\ninst✝ : Category.{v₁, u₁} T\nY : T\nx y : Over Y\nu : x ⟶ y\n⊢ (map (𝟙 Y)).map u = eqToHom ⋯ ≫ (𝟭 (Over Y)).map u ≫ eqToHom ⋯",
"usedConstants": [
"CategoryTheory.Over.map",
"Eq.mpr",
"CategoryTheory.Over",
"CategoryTheory.Comma.right",
"Cate... | dsimp [Over, Over.map, Comma.mapRight] | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.CategoryTheory.Limits.Shapes.Kernels | {
"line": 213,
"column": 7
} | {
"line": 213,
"column": 60
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : HasZeroMorphisms C\nX✝ Y✝ : C\nf : X✝ ⟶ Y✝\nX Y : C\ng : X ⟶ Y\nc : KernelFork g\nhc : IsLimit c\nX' Y' : C\ng' : X' ⟶ Y'\ne : X ≅ X'\niff : ∀ ⦃W : C⦄ (φ : W ⟶ X), φ ≫ g = 0 ↔ φ ≫ e.hom ≫ g' = 0\nW'✝ : C\ns : W'✝ ⟶ X'\nhs : s ≫ g' = 0\n⊢ (s ≫ e.inv) ≫ g =... | by rw [iff, Category.assoc, Iso.inv_hom_id_assoc, hs] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Kernels | {
"line": 1225,
"column": 8
} | {
"line": 1225,
"column": 78
} | [
{
"pp": "C : Type u\ninst✝⁸ : Category.{v, u} C\ninst✝⁷ : HasZeroMorphisms C\nX Y : C\nf : X ⟶ Y\nD : Type u₂\ninst✝⁶ : Category.{v₂, u₂} D\ninst✝⁵ : HasZeroMorphisms D\nG : C ⥤ D\ninst✝⁴ : G.PreservesZeroMorphisms\nX' Y' : C\ninst✝³ : HasKernel f\ninst✝² : HasKernel (G.map f)\ng : X' ⟶ Y'\ninst✝¹ : HasKernel g... | simp only [← G.map_comp]; exact G.congr_map (kernel.lift_ι _ _ _).symm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Kernels | {
"line": 1225,
"column": 8
} | {
"line": 1225,
"column": 78
} | [
{
"pp": "C : Type u\ninst✝⁸ : Category.{v, u} C\ninst✝⁷ : HasZeroMorphisms C\nX Y : C\nf : X ⟶ Y\nD : Type u₂\ninst✝⁶ : Category.{v₂, u₂} D\ninst✝⁵ : HasZeroMorphisms D\nG : C ⥤ D\ninst✝⁴ : G.PreservesZeroMorphisms\nX' Y' : C\ninst✝³ : HasKernel f\ninst✝² : HasKernel (G.map f)\ng : X' ⟶ Y'\ninst✝¹ : HasKernel g... | simp only [← G.map_comp]; exact G.congr_map (kernel.lift_ι _ _ _).symm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Preadditive.FunctorCategory | {
"line": 56,
"column": 8
} | {
"line": 56,
"column": 22
} | [
{
"pp": "case w.h\nC : Type u_1\nD : Type u_2\ninst✝² : Category.{v_1, u_1} C\ninst✝¹ : Category.{v_2, u_2} D\ninst✝ : Preadditive D\nF G : C ⥤ D\na✝ b✝ : F ⟶ G\nx✝ : C\n⊢ (a✝ + b✝).app x✝ = (b✝ + a✝).app x✝",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"AddC... | apply add_comm | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {
"line": 614,
"column": 2
} | {
"line": 615,
"column": 78
} | [
{
"pp": "C : Type uC\ninst✝³ : Category.{uC', uC} C\ninst✝² : HasZeroMorphisms C\nW X Y Z : C\ninst✝¹ : HasBinaryBiproduct W X\ninst✝ : HasBinaryBiproduct Y Z\nf : W ⟶ Y\ng : X ⟶ Z\n⊢ inl ≫ map f g = f ≫ inl",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.H... | rw [biprod.map_eq_map']
exact IsColimit.ι_map (BinaryBiproduct.isColimit W X) _ _ ⟨WalkingPair.left⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {
"line": 614,
"column": 2
} | {
"line": 615,
"column": 78
} | [
{
"pp": "C : Type uC\ninst✝³ : Category.{uC', uC} C\ninst✝² : HasZeroMorphisms C\nW X Y Z : C\ninst✝¹ : HasBinaryBiproduct W X\ninst✝ : HasBinaryBiproduct Y Z\nf : W ⟶ Y\ng : X ⟶ Z\n⊢ inl ≫ map f g = f ≫ inl",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.H... | rw [biprod.map_eq_map']
exact IsColimit.ι_map (BinaryBiproduct.isColimit W X) _ _ ⟨WalkingPair.left⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 539,
"column": 6
} | {
"line": 539,
"column": 16
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsLimit b.sndKernelFork\nT : C\nf : T ⟶ X\ng : T ⟶ Y\nm : T ⟶ b.toCone.pt\nh₁ : m ≫ BinaryFan.fst b.toCone = f\nh₂ : m ≫ BinaryFan.snd b.toCone = g\n⊢ m = (fu... | dsimp at m | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 947,
"column": 8
} | {
"line": 954,
"column": 28
} | [
{
"pp": "J✝ : 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✝¹ : Finite K\nins... | classical
intro W g' w
ext j
simp only [biproduct.toSubtype_fromSubtype_assoc, Pi.compl_apply, biproduct.ι_map_assoc]
split_ifs with h
· simp
· replace w := biproduct.ι _ (⟨j, not_not.mp h⟩ : Subtype p) ≫= w
simpa using w.symm | Lean.Elab.Tactic.evalClassical | Lean.Parser.Tactic.classical |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 947,
"column": 8
} | {
"line": 954,
"column": 28
} | [
{
"pp": "J✝ : 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✝¹ : Finite K\nins... | classical
intro W g' w
ext j
simp only [biproduct.toSubtype_fromSubtype_assoc, Pi.compl_apply, biproduct.ι_map_assoc]
split_ifs with h
· simp
· replace w := biproduct.ι _ (⟨j, not_not.mp h⟩ : Subtype p) ≫= w
simpa using w.symm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 947,
"column": 8
} | {
"line": 954,
"column": 28
} | [
{
"pp": "J✝ : 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✝¹ : Finite K\nins... | classical
intro W g' w
ext j
simp only [biproduct.toSubtype_fromSubtype_assoc, Pi.compl_apply, biproduct.ι_map_assoc]
split_ifs with h
· simp
· replace w := biproduct.ι _ (⟨j, not_not.mp h⟩ : Subtype p) ≫= w
simpa using w.symm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 556,
"column": 6
} | {
"line": 556,
"column": 16
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsLimit b.fstKernelFork\nT : C\nf : T ⟶ X\ng : T ⟶ Y\nm : T ⟶ b.toCone.pt\nh₁ : m ≫ BinaryFan.fst b.toCone = f\nh₂ : m ≫ BinaryFan.snd b.toCone = g\n⊢ m = (fu... | dsimp at m | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 572,
"column": 6
} | {
"line": 572,
"column": 16
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsColimit b.inrCokernelCofork\nT : C\nf : X ⟶ T\ng : Y ⟶ T\nm : b.toCocone.pt ⟶ T\nh₁ : BinaryCofan.inl b.toCocone ≫ m = f\nh₂ : BinaryCofan.inr b.toCocone ≫ ... | dsimp at m | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 588,
"column": 6
} | {
"line": 588,
"column": 16
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsColimit b.inlCokernelCofork\nT : C\nf : X ⟶ T\ng : Y ⟶ T\nm : b.toCocone.pt ⟶ T\nh₁ : BinaryCofan.inl b.toCocone ≫ m = f\nh₂ : BinaryCofan.inr b.toCocone ≫ ... | dsimp at m | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 593,
"column": 6
} | {
"line": 594,
"column": 18
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsColimit b.inlCokernelCofork\nT : C\nf : X ⟶ T\ng : Y ⟶ T\nm : b.pt ⟶ T\nh₁ : BinaryCofan.inl b.toCocone ≫ m = f\nh₂ : BinaryCofan.inr b.toCocone ≫ m = g\nh₁... | rw [← sub_eq_zero, ← hq, ← Category.id_comp q, ← b.inr_snd, Category.assoc, hq, h₂',
comp_zero] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Combinatorics.Enumerative.Composition | {
"line": 272,
"column": 77
} | {
"line": 272,
"column": 97
} | [
{
"pp": "n : ℕ\nc : Composition n\n⊢ c.boundaries.card = c.length + 1",
"usedConstants": [
"Fintype.card_fin",
"Finset.univ",
"Composition.length",
"congrArg",
"Finset.card_map",
"Finset.map",
"RelEmbedding.toEmbedding",
"instOfNatNat",
"LE.le",
"i... | by simp [boundaries] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Fintype.Inv | {
"line": 98,
"column": 2
} | {
"line": 98,
"column": 79
} | [
{
"pp": "case h.a\nα : Type u_1\nβ : Type u_2\ninst✝² : Fintype α\ninst✝¹ : DecidableEq β\nf : α ↪ β\ninst✝ : Nonempty α\nb : β\nh : b ∈ Set.range ⇑f\n⊢ f ((Set.range ⇑f).restrict (invFun ⇑f) ⟨b, h⟩) = f (f.invOfMemRange ⟨b, h⟩)",
"usedConstants": [
"Function.invFun",
"Function.Embedding.invOfMe... | simp [f.left_inv_of_invOfMemRange, @invFun_eq _ _ _ f b (Set.mem_range.mp h)] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Combinatorics.Enumerative.Composition | {
"line": 552,
"column": 4
} | {
"line": 557,
"column": 33
} | [
{
"pp": "case mpr\nn : ℕ\nh : 0 < n\nc : Composition n\n⊢ c.length = 1 → c = single n h",
"usedConstants": [
"Eq.mpr",
"Nat.instMulZeroClass",
"Composition.ext",
"and_true",
"Composition.length",
"congrArg",
"List.get",
"Composition.blocks",
"AddMonoid.t... | intro H
ext1
have A : c.blocks.length = 1 := H ▸ c.blocks_length
have B : c.blocks.sum = n := c.blocks_sum
rw [eq_cons_of_length_one A] at B ⊢
simpa [single_blocks] using B | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.Enumerative.Composition | {
"line": 552,
"column": 4
} | {
"line": 557,
"column": 33
} | [
{
"pp": "case mpr\nn : ℕ\nh : 0 < n\nc : Composition n\n⊢ c.length = 1 → c = single n h",
"usedConstants": [
"Eq.mpr",
"Nat.instMulZeroClass",
"Composition.ext",
"and_true",
"Composition.length",
"congrArg",
"List.get",
"Composition.blocks",
"AddMonoid.t... | intro H
ext1
have A : c.blocks.length = 1 := H ▸ c.blocks_length
have B : c.blocks.sum = n := c.blocks_sum
rw [eq_cons_of_length_one A] at B ⊢
simpa [single_blocks] using B | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Enumerative.Composition | {
"line": 673,
"column": 6
} | {
"line": 673,
"column": 20
} | [
{
"pp": "case h.e'_1\nn✝¹ : ℕ\nc✝¹ : Composition n✝¹\nm : ℕ\nmotive : (n : ℕ) → Composition n → Sort u_1\nn✝ : ℕ\nc✝ : Composition n✝\nzero : motive 0 (ones 0)\nappend_single : (k n : ℕ) → (c : Composition n) → motive n c → motive (n + (k + 1)) (c.append (single (k + 1) ⋯))\nk n : ℕ\nc : Composition n\nih : mot... | apply add_comm | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Combinatorics.Enumerative.Composition | {
"line": 673,
"column": 6
} | {
"line": 673,
"column": 20
} | [
{
"pp": "case h.e'_1\nn✝¹ : ℕ\nc✝¹ : Composition n✝¹\nm : ℕ\nmotive : (n : ℕ) → Composition n → Sort u_1\nn✝ : ℕ\nc✝ : Composition n✝\nzero : motive 0 (ones 0)\nappend_single : (k n : ℕ) → (c : Composition n) → motive n c → motive (n + (k + 1)) (c.append (single (k + 1) ⋯))\nk n : ℕ\nc : Composition n\nih : mot... | apply add_comm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.Enumerative.Composition | {
"line": 673,
"column": 6
} | {
"line": 673,
"column": 20
} | [
{
"pp": "case h.e'_1\nn✝¹ : ℕ\nc✝¹ : Composition n✝¹\nm : ℕ\nmotive : (n : ℕ) → Composition n → Sort u_1\nn✝ : ℕ\nc✝ : Composition n✝\nzero : motive 0 (ones 0)\nappend_single : (k n : ℕ) → (c : Composition n) → motive n c → motive (n + (k + 1)) (c.append (single (k + 1) ⋯))\nk n : ℕ\nc : Composition n\nih : mot... | apply add_comm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Logic.Equiv.Fintype | {
"line": 127,
"column": 45
} | {
"line": 130,
"column": 69
} | [
{
"pp": "α : Type u_1\ninst✝² : Finite α\np q : α → Prop\ninst✝¹ : DecidablePred p\ninst✝ : DecidablePred q\ne : { x // p x } ≃ { x // q x }\nx : α\nhx : ¬p x\n⊢ e.extendSubtype x = ↑(e.toCompl ⟨x, hx⟩)",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"Sum.map",
"congrArg",
... | by
dsimp only [extendSubtype]
simp only [subtypeCongr, Equiv.trans_apply, Equiv.sumCongr_apply]
rw [sumCompl_symm_apply_of_neg hx, Sum.map_inr, sumCompl_apply_inr] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.Support | {
"line": 206,
"column": 6
} | {
"line": 206,
"column": 66
} | [
{
"pp": "case neg\nα : Type u_1\ninst✝¹ : DecidableEq α\np : α → Prop\ninst✝ : DecidablePred p\nx y : Subtype p\nz : α\nhz : ¬p z\n⊢ (ofSubtype (swap x y)) z = (swap ↑x ↑y) z",
"usedConstants": [
"Eq.mpr",
"MonoidHom.instFunLike",
"Equiv.instEquivLike",
"MonoidHom",
"Monoid.toM... | rw [ofSubtype_apply_of_not_mem _ hz, swap_apply_of_ne_of_ne] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Combinatorics.Enumerative.Composition | {
"line": 921,
"column": 4
} | {
"line": 921,
"column": 81
} | [
{
"pp": "case succ\nn : ℕ\nc : CompositionAsSet n\ni : ℕ\nIH : ∀ (h : i < c.boundaries.card), (take i c.blocks).sum = ↑(c.boundary ⟨i, h⟩)\nh : i + 1 < c.boundaries.card\nA : i < c.blocks.length\n⊢ (take (i + 1) c.blocks).sum = ↑(c.boundary ⟨i + 1, h⟩)",
"usedConstants": [
"Nat.instCanonicallyOrderedA... | have B : i < c.boundaries.card := lt_of_lt_of_le A (by simp [blocks, length]) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.GroupTheory.Perm.List | {
"line": 170,
"column": 4
} | {
"line": 170,
"column": 78
} | [
{
"pp": "case succ.cons.nil\nα : Type u_1\ninst✝ : DecidableEq α\nn : ℕ\nIH : ∀ (xs : List α), xs.Nodup → ∀ (hn : n + 1 < xs.length), xs.formPerm xs[n] = xs[n + 1]\nx : α\nh : [x].Nodup\nhn : n + 1 + 1 < [x].length\n⊢ [x].formPerm [x][n + 1] = [x][n + 1 + 1]",
"usedConstants": [
"List.formPerm_apply_l... | · rw [formPerm_singleton, getElem_singleton, getElem_singleton, one_apply] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.GroupTheory.Perm.List | {
"line": 175,
"column": 10
} | {
"line": 175,
"column": 15
} | [
{
"pp": "case succ.cons.cons\nα : Type u_1\ninst✝ : DecidableEq α\nn : ℕ\nIH✝ : ∀ (xs : List α), xs.Nodup → ∀ (hn : n + 1 < xs.length), xs.formPerm xs[n] = xs[n + 1]\nx y : α\nl : List α\nh : (x :: y :: l).Nodup\nhn : n + 1 + 1 < (x :: y :: l).length\nIH : (y :: l).formPerm (y :: l)[n] = l[n]\n⊢ (y :: l).formPe... | ← IH, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.List | {
"line": 203,
"column": 33
} | {
"line": 203,
"column": 51
} | [
{
"pp": "case a\nα : Type u_1\ninst✝ : DecidableEq α\nl : List α\nh : Function.Injective l.get\nh' : ∀ (x : α), l ≠ [x]\nn : ℕ\nhn : n < l.length\nhx : l[n] ∈ l\nH : l[(n + 1) % l.length] = l[n]\n⊢ False",
"usedConstants": [
"congrArg",
"Function.Injective.eq_1",
"List.get",
"Eq.mp",... | Function.Injective | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.List | {
"line": 288,
"column": 2
} | {
"line": 288,
"column": 7
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nx y x' y' : α\nl l' : List α\nhd : (x :: y :: l).Nodup\nhd' : (x' :: y' :: l').Nodup\nh : ∀ (x_1 : α), (x :: y :: l).formPerm x_1 = (x' :: y' :: l').formPerm x_1\nhx : x' ∈ x :: y :: l\nn : ℕ\nhn : n < (x :: y :: l).length\nhx' : (x :: y :: l).get ⟨n, hn⟩ = x'\nhl :... | use n | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.GroupTheory.Perm.Finite | {
"line": 168,
"column": 4
} | {
"line": 168,
"column": 41
} | [
{
"pp": "case pos\nα : Type u\nβ : Type v\np : β → Prop\ninst✝ : DecidablePred p\nf : α ≃ Subtype p\nσ τ : Perm α\nh : σ.Disjoint τ\nb : β\npb : p b\n⊢ (σ.extendDomain f) b = b ∨ (τ.extendDomain f) b = b",
"usedConstants": [
"Equiv.instEquivLike",
"Equiv.Perm.extendDomain",
"Equiv",
... | refine (h (f.symm ⟨b, pb⟩)).imp ?_ ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.GroupTheory.Perm.Support | {
"line": 598,
"column": 44
} | {
"line": 598,
"column": 100
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nf : Perm α\nh : #f.support = 2\nx y : α\nhmem : ¬x = y\nhins : {x, y} = f.support\nht : #{y} = 1\na b : α\n⊢ f b ≠ b ↔ ?m.105 b",
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.support",
"Finset.mem_singleton",
"Equiv.instEq... | by rw [← mem_support, ← hins, mem_insert, mem_singleton] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.Support | {
"line": 598,
"column": 4
} | {
"line": 598,
"column": 100
} | [
{
"pp": "case mp.H\nα : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nf : Perm α\nh : #f.support = 2\nx y : α\nhmem : ¬x = y\nhins : {x, y} = f.support\nht : #{y} = 1\na : α\n⊢ f a = (swap x y) a",
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.support",
"Finset.mem_singleton",
"Equ... | have key : ∀ b, f b ≠ b ↔ _ := fun b => by rw [← mem_support, ← hins, mem_insert, mem_singleton] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.GroupTheory.Perm.Sign | {
"line": 50,
"column": 59
} | {
"line": 50,
"column": 87
} | [
{
"pp": "α : Type u\ninst✝ : DecidableEq α\nβ : Type v\ni j : α\nσ τ : Perm α\nh✝ : σ = τ ∨ σ = swap i j * τ\nh : σ = swap i j * τ\n⊢ τ = swap i j * σ",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"Equiv.swap",
"id",
"Equiv.Perm",
"Equiv.Perm.instMul",
... | by rw [h, swap_mul_self_mul] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.List | {
"line": 374,
"column": 4
} | {
"line": 379,
"column": 20
} | [
{
"pp": "case neg\nα : Type u_1\ninst✝ : DecidableEq α\nl : List α\nhl : l.Nodup\nx : α\nhx : x ∉ l\n⊢ (l.formPerm ^ l.length) x = 1 x",
"usedConstants": [
"Equiv.instEquivLike",
"Equiv.Perm.instOne",
"Equiv.Perm.set_support_zpow_subset",
"congrArg",
"Finset",
"List.coe_t... | have : x ∉ { x | (l.formPerm ^ l.length) x ≠ x } := by
intro H
refine hx ?_
replace H := set_support_zpow_subset l.formPerm l.length H
simpa using support_formPerm_le' _ H
simpa using this | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.List | {
"line": 374,
"column": 4
} | {
"line": 379,
"column": 20
} | [
{
"pp": "case neg\nα : Type u_1\ninst✝ : DecidableEq α\nl : List α\nhl : l.Nodup\nx : α\nhx : x ∉ l\n⊢ (l.formPerm ^ l.length) x = 1 x",
"usedConstants": [
"Equiv.instEquivLike",
"Equiv.Perm.instOne",
"Equiv.Perm.set_support_zpow_subset",
"congrArg",
"Finset",
"List.coe_t... | have : x ∉ { x | (l.formPerm ^ l.length) x ≠ x } := by
intro H
refine hx ?_
replace H := set_support_zpow_subset l.formPerm l.length H
simpa using support_formPerm_le' _ H
simpa using this | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Sign | {
"line": 159,
"column": 8
} | {
"line": 159,
"column": 48
} | [
{
"pp": "α : Type u\ninst✝ : DecidableEq α\nw x y✝ z✝ : α\nhwx : w ≠ x\nhyz✝ : y✝ ≠ z✝\ny z : α\nhyz : y ≠ z\nhwz : w ≠ z\n⊢ swap w y * swap z w * swap w y = swap y z",
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"HMul.hMul",
"congrArg",
"Equiv.swap",
"id",
"Div... | swap_mul_swap_mul_swap hwz.symm hyz.symm | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Sign | {
"line": 417,
"column": 2
} | {
"line": 417,
"column": 65
} | [
{
"pp": "α : Type u\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nl : List (Perm α)\nhl : ∀ g ∈ l, g.IsSwap\nh₁ : List.map (⇑sign) l = List.replicate l.length (-1)\n⊢ sign l.prod = (-1) ^ l.length",
"usedConstants": [
"Eq.mpr",
"List.replicate",
"MonoidHom.instMonoidHomClass",
"MulOne.... | rw [← List.prod_replicate, ← h₁, List.prod_hom _ (@sign α _ _)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Perm.Sign | {
"line": 509,
"column": 4
} | {
"line": 510,
"column": 47
} | [
{
"pp": "case H.nil\nβ : Type v\nα : Type u_1\ninst✝ : DecidableEq α\nσ : α → Perm β\na : α\nb : β\nhl : [].Nodup\n⊢ a ∈ [] ∧ (List.map (fun a ↦ prodExtendRight a (σ a)) []).prod (a, b) = (a, (σ a) b) ∨\n a ∉ [] ∧ (List.map (fun a ↦ prodExtendRight a (σ a)) []).prod (a, b) = (a, b)",
"usedConstants": [
... | refine Or.inr ⟨List.not_mem_nil, ?_⟩
rw [List.map_nil, List.prod_nil, one_apply] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Sign | {
"line": 509,
"column": 4
} | {
"line": 510,
"column": 47
} | [
{
"pp": "case H.nil\nβ : Type v\nα : Type u_1\ninst✝ : DecidableEq α\nσ : α → Perm β\na : α\nb : β\nhl : [].Nodup\n⊢ a ∈ [] ∧ (List.map (fun a ↦ prodExtendRight a (σ a)) []).prod (a, b) = (a, (σ a) b) ∨\n a ∉ [] ∧ (List.map (fun a ↦ prodExtendRight a (σ a)) []).prod (a, b) = (a, b)",
"usedConstants": [
... | refine Or.inr ⟨List.not_mem_nil, ?_⟩
rw [List.map_nil, List.prod_nil, one_apply] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Sign | {
"line": 560,
"column": 4
} | {
"line": 564,
"column": 66
} | [
{
"pp": "case left\nα : Type u\ninst✝³ : DecidableEq α\nβ : Type v\ninst✝² : Fintype α\ninst✝¹ : DecidableEq β\ninst✝ : Fintype β\nσa : Perm α\nσb : Perm β\n⊢ sign (σa.sumCongr 1) = sign σa",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"MulOne.toOne",
"instFintypeSum",
"MonoidHom.i... | induction σa using swap_induction_on with
| one => simp
| swap_mul σa' a₁ a₂ ha ih =>
rw [← one_mul (1 : Perm β), ← sumCongr_mul, sign_mul, sign_mul, ih, sumCongr_swap_one,
sign_swap ha, sign_swap (Sum.inl_injective.ne_iff.mpr ha)] | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.GroupTheory.Perm.Sign | {
"line": 560,
"column": 4
} | {
"line": 564,
"column": 66
} | [
{
"pp": "case left\nα : Type u\ninst✝³ : DecidableEq α\nβ : Type v\ninst✝² : Fintype α\ninst✝¹ : DecidableEq β\ninst✝ : Fintype β\nσa : Perm α\nσb : Perm β\n⊢ sign (σa.sumCongr 1) = sign σa",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"MulOne.toOne",
"instFintypeSum",
"MonoidHom.i... | induction σa using swap_induction_on with
| one => simp
| swap_mul σa' a₁ a₂ ha ih =>
rw [← one_mul (1 : Perm β), ← sumCongr_mul, sign_mul, sign_mul, ih, sumCongr_swap_one,
sign_swap ha, sign_swap (Sum.inl_injective.ne_iff.mpr ha)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Sign | {
"line": 560,
"column": 4
} | {
"line": 564,
"column": 66
} | [
{
"pp": "case left\nα : Type u\ninst✝³ : DecidableEq α\nβ : Type v\ninst✝² : Fintype α\ninst✝¹ : DecidableEq β\ninst✝ : Fintype β\nσa : Perm α\nσb : Perm β\n⊢ sign (σa.sumCongr 1) = sign σa",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"MulOne.toOne",
"instFintypeSum",
"MonoidHom.i... | induction σa using swap_induction_on with
| one => simp
| swap_mul σa' a₁ a₂ ha ih =>
rw [← one_mul (1 : Perm β), ← sumCongr_mul, sign_mul, sign_mul, ih, sumCongr_swap_one,
sign_swap ha, sign_swap (Sum.inl_injective.ne_iff.mpr ha)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.NoncommPiCoprod | {
"line": 267,
"column": 4
} | {
"line": 267,
"column": 54
} | [
{
"pp": "G : Type u_1\ninst✝³ : Group G\nι : Type u_2\nH : ι → Type u_3\ninst✝² : (i : ι) → Group (H i)\nϕ : (i : ι) → H i →* G\nhcomm : Pairwise fun i j ↦ ∀ (x : H i) (y : H j), Commute ((ϕ i) x) ((ϕ j) y)\ninst✝¹ : Finite ι\ninst✝ : (i : ι) → Fintype (H i)\nhcoprime : Pairwise fun i j ↦ (Fintype.card (H i)).C... | exact (orderOf_map_dvd _ _).trans orderOf_dvd_card | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.GroupTheory.NoncommPiCoprod | {
"line": 270,
"column": 4
} | {
"line": 270,
"column": 54
} | [
{
"pp": "G : Type u_1\ninst✝³ : Group G\nι : Type u_2\nH : ι → Type u_3\ninst✝² : (i : ι) → Group (H i)\nϕ : (i : ι) → H i →* G\nhcomm : Pairwise fun i j ↦ ∀ (x : H i) (y : H j), Commute ((ϕ i) x) ((ϕ j) y)\ninst✝¹ : Finite ι\ninst✝ : (i : ι) → Fintype (H i)\nhcoprime : Pairwise fun i j ↦ (Fintype.card (H i)).C... | exact (orderOf_map_dvd _ _).trans orderOf_dvd_card | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.GroupTheory.NoncommPiCoprod | {
"line": 340,
"column": 2
} | {
"line": 340,
"column": 56
} | [
{
"pp": "G : Type u_1\ninst✝¹ : Group G\nι : Type u_2\nH : ι → Subgroup G\ninst✝ : Fintype ι\nhcomm : Pairwise fun i j ↦ ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y\nhind : iSupIndep H\n⊢ Function.Injective ⇑(noncommPiCoprod hcomm)",
"usedConstants": [
"Subgroup.subtype",
"Membership.mem",
... | apply MonoidHom.injective_noncommPiCoprod_of_iSupIndep | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 195,
"column": 2
} | {
"line": 204,
"column": 25
} | [
{
"pp": "α : Type u_2\nf : Perm α\nx y : α\ninst✝² : DecidableRel f.SameCycle\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\n⊢ y ∈ (f.cycleOf x).support ↔ f.SameCycle x y ∧ x ∈ f.support",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Equiv.Perm.support",
"False",
"Equiv.Perm.notMem_su... | by_cases hx : f x = x
· rw [(cycleOf_eq_one_iff _).mpr hx]
simp [hx]
· rw [mem_support, cycleOf_apply]
split_ifs with hy
· simp only [hx, hy, Ne, not_false_iff, and_self_iff, mem_support]
rcases hy with ⟨k, rfl⟩
rw [← notMem_support]
simpa using hx
· simpa [hx] using hy | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 195,
"column": 2
} | {
"line": 204,
"column": 25
} | [
{
"pp": "α : Type u_2\nf : Perm α\nx y : α\ninst✝² : DecidableRel f.SameCycle\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\n⊢ y ∈ (f.cycleOf x).support ↔ f.SameCycle x y ∧ x ∈ f.support",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Equiv.Perm.support",
"False",
"Equiv.Perm.notMem_su... | by_cases hx : f x = x
· rw [(cycleOf_eq_one_iff _).mpr hx]
simp [hx]
· rw [mem_support, cycleOf_apply]
split_ifs with hy
· simp only [hx, hy, Ne, not_false_iff, and_self_iff, mem_support]
rcases hy with ⟨k, rfl⟩
rw [← notMem_support]
simpa using hx
· simpa [hx] using hy | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 243,
"column": 6
} | {
"line": 243,
"column": 23
} | [
{
"pp": "case mp\nι : Type u_1\nα : Type u_2\nβ : Type u_3\nf✝ g : Perm α\nx✝ y✝ : α\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nf : Perm α\nx y : α\n⊢ (∃ m < Fintype.card α, (f ^ m) x = y) → f.SameCycle x y",
"usedConstants": [
"Equiv.instEquivLike",
"Equiv.Perm.instPowNat",
"Exists",
... | rintro ⟨n, _, hn⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 1038,
"column": 2
} | {
"line": 1040,
"column": 14
} | [
{
"pp": "case neg\nα : Type u_2\ninst✝¹ : Fintype α\ninst✝ : DecidableEq α\ng c : Perm α\nhc : c.IsCycle\nhc' : ∀ (x : α), g x ∈ c.support ↔ x ∈ c.support\nk : ℤ\na : α\nha : a ∉ c.support\n⊢ a ∈ c.support → (c ^ k) a = g a ↔ (c ^ k) a = (ofSubtype (g.subtypePerm ⋯)) a",
"usedConstants": [
"Iff.mpr",
... | · rw [iff_true_left (fun b ↦ (ha b).elim), ofSubtype_apply_of_not_mem, ← notMem_support]
· exact Finset.notMem_mono (support_zpow_le c k) ha
· exact ha | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.GroupTheory.Perm.Cycle.Factors | {
"line": 408,
"column": 8
} | {
"line": 408,
"column": 30
} | [
{
"pp": "case refine_3\nι : 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\... | by_contra! ⟨hgy, hg'y⟩ | Mathlib.Tactic.ByContra._aux_Mathlib_Tactic_ByContra___macroRules_Mathlib_Tactic_ByContra_byContra!_1 | Mathlib.Tactic.ByContra.byContra! |
Mathlib.GroupTheory.Perm.Fin | {
"line": 182,
"column": 29
} | {
"line": 182,
"column": 40
} | [
{
"pp": "n : ℕ\ni j : Fin n\ninst✝ : NeZero n\nh : i < j\n⊢ (if i = j then 0 else i + 1) = i + 1",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"instDecidableEqFin",
"id",
"Fin.instOfNat",
"instHAdd",
"Fin.instPartialOrder",
"HAdd.... | if_neg h.ne | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Fin | {
"line": 185,
"column": 33
} | {
"line": 185,
"column": 44
} | [
{
"pp": "n : ℕ\ni j : Fin n\nh : i < j\n⊢ (if i = j then 0 else ↑i + 1) = ↑i + 1",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"instDecidableEqFin",
"id",
"instOfNatNat",
"Fin.val",
"instHAdd",
"Fin.instPartialOrder",
"HAdd.... | if_neg h.ne | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Fin | {
"line": 453,
"column": 4
} | {
"line": 453,
"column": 68
} | [
{
"pp": "case h.h.inl\nn : ℕ\ni j k : Fin n\ninst✝ : NeZero n\nhij : i ≤ j\nhjk : j ≤ k\nx : Fin n\nch : x < i\n⊢ ↑((⇑(i.cycleIcc j) ∘ ⇑(j.cycleIcc k)) x) = ↑((i.cycleIcc k) x)",
"usedConstants": [
"Equiv.instEquivLike",
"congrArg",
"PartialOrder.toPreorder",
"Function.comp",
"... | simp [cycleIcc_of_lt (lt_of_lt_of_le ch hij), cycleIcc_of_lt ch] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.GroupTheory.Perm.Fin | {
"line": 453,
"column": 4
} | {
"line": 453,
"column": 68
} | [
{
"pp": "case h.h.inl\nn : ℕ\ni j k : Fin n\ninst✝ : NeZero n\nhij : i ≤ j\nhjk : j ≤ k\nx : Fin n\nch : x < i\n⊢ ↑((⇑(i.cycleIcc j) ∘ ⇑(j.cycleIcc k)) x) = ↑((i.cycleIcc k) x)",
"usedConstants": [
"Equiv.instEquivLike",
"congrArg",
"PartialOrder.toPreorder",
"Function.comp",
"... | simp [cycleIcc_of_lt (lt_of_lt_of_le ch hij), cycleIcc_of_lt ch] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Fin | {
"line": 453,
"column": 4
} | {
"line": 453,
"column": 68
} | [
{
"pp": "case h.h.inl\nn : ℕ\ni j k : Fin n\ninst✝ : NeZero n\nhij : i ≤ j\nhjk : j ≤ k\nx : Fin n\nch : x < i\n⊢ ↑((⇑(i.cycleIcc j) ∘ ⇑(j.cycleIcc k)) x) = ↑((i.cycleIcc k) x)",
"usedConstants": [
"Equiv.instEquivLike",
"congrArg",
"PartialOrder.toPreorder",
"Function.comp",
"... | simp [cycleIcc_of_lt (lt_of_lt_of_le ch hij), cycleIcc_of_lt ch] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Fin | {
"line": 517,
"column": 2
} | {
"line": 517,
"column": 71
} | [
{
"pp": "case inl\nn : ℕ\nR : Type u_1\ninst✝ : CommRing R\nσ : Perm (Fin n)\nf : Fin n → Fin n → R\nhf : ∀ (i j : Fin n), f i j = -f j i\nD : Finset ((_ : Fin n) × Fin n) := Finset.univ.sigma Finset.Iio\nhD : D = Finset.univ.sigma Finset.Iio\nhφD : Finset.image (fun x ↦ ⟨max (σ x.fst) (σ x.snd), min (σ x.fst) ... | · simp [inf_eq_left.2 hlt.le, sup_eq_right.2 hlt.le, hx.not_gt, ← hf] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.LinearAlgebra.Multilinear.Basic | {
"line": 207,
"column": 6
} | {
"line": 207,
"column": 37
} | [
{
"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✝¹³ : Semiring R\ninst✝¹² : (i : Fin n.succ) → AddCommMonoid (M i)\ninst✝¹¹ : (i : ι) → AddCommMonoid (M₁ i)\nin... | simp [← smul_comm x c (_ : M₂)] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.LinearAlgebra.Multilinear.Basic | {
"line": 207,
"column": 6
} | {
"line": 207,
"column": 37
} | [
{
"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✝¹³ : Semiring R\ninst✝¹² : (i : Fin n.succ) → AddCommMonoid (M i)\ninst✝¹¹ : (i : ι) → AddCommMonoid (M₁ i)\nin... | simp [← smul_comm x c (_ : M₂)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.LinearAlgebra.Multilinear.Basic | {
"line": 207,
"column": 6
} | {
"line": 207,
"column": 37
} | [
{
"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✝¹³ : Semiring R\ninst✝¹² : (i : Fin n.succ) → AddCommMonoid (M i)\ninst✝¹¹ : (i : ι) → AddCommMonoid (M₁ i)\nin... | simp [← smul_comm x c (_ : M₂)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.Alternating.Basic | {
"line": 192,
"column": 6
} | {
"line": 192,
"column": 24
} | [
{
"pp": "R : Type u_1\ninst✝⁴ : Semiring R\nM : Type u_2\ninst✝³ : AddCommMonoid M\ninst✝² : Module R M\nN : Type u_3\ninst✝¹ : AddCommMonoid N\ninst✝ : Module R N\nι : Type u_7\nf : M [⋀^ι]→ₗ[R] N\nv : ι → M\nhv : ¬Injective v\n⊢ f v = 0",
"usedConstants": [
"congrArg",
"Function.Injective.eq_1... | Function.Injective | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Cycle.Type | {
"line": 346,
"column": 6
} | {
"line": 346,
"column": 25
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\ninst✝ : DecidableEq α\nσ : Perm α\nn : ℕ\nhn : 0 < n\nhσ : σ.cycleType = Multiset.replicate σ.cycleType.card n\n⊢ sign σ = if Odd n then 1 else (-1) ^ ((Fintype.card α - Fintype.card ↑(Function.fixedPoints ⇑σ)) / n)",
"usedConstants": [
"Int.instCommMonoid",
... | sign_of_cycleType', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.Alternating.Basic | {
"line": 779,
"column": 2
} | {
"line": 779,
"column": 57
} | [
{
"pp": "ι : Type u_7\nK : Type u_12\nM : Type u_13\nN : Type u_14\ninst✝⁶ : Ring K\ninst✝⁵ : IsDomain K\ninst✝⁴ : AddCommGroup M\ninst✝³ : Module K M\ninst✝² : AddCommGroup N\ninst✝¹ : Module K N\ninst✝ : IsTorsionFree K N\nf : M [⋀^ι]→ₗ[K] N\nv : ι → M\nh✝ : ¬LinearIndependent K v\ns : Finset ι\ng : ι → K\ni ... | rw [h, f.map_update_neg, f.map_update_sum, neg_eq_zero] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.LinearAlgebra.Multilinear.Basic | {
"line": 454,
"column": 33
} | {
"line": 454,
"column": 64
} | [
{
"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... | Finset.sum_powerset_insert hit, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.Multilinear.Basic | {
"line": 461,
"column": 6
} | {
"line": 461,
"column": 64
} | [
{
"pp": "case pos\nR : 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 ... | simp [m'', Finset.notMem_of_mem_powerset_of_notMem hs hit] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.GroupTheory.Perm.Cycle.Type | {
"line": 451,
"column": 17
} | {
"line": 451,
"column": 36
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\nG : Type u_2\ninst✝ : Group G\nn : ℕ\nv : List.Vector G n\n⊢ (v.toList.prod⁻¹ ::ᵥ v).toList.prod = 1",
"usedConstants": [
"Eq.mpr",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Group.... | Vector.toList_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.Matrix.Reindex | {
"line": 66,
"column": 76
} | {
"line": 68,
"column": 5
} | [
{
"pp": "m : Type u_2\nn : Type u_3\nm' : Type u_6\nn' : Type u_7\nm'' : Type u_9\nn'' : Type u_10\nR : Type u_11\nA : Type u_12\ninst✝² : Semiring R\ninst✝¹ : AddCommMonoid A\ninst✝ : Module R A\ne₁ : m ≃ m'\ne₂ : n ≃ n'\ne₁' : m' ≃ m''\ne₂' : n' ≃ n''\n⊢ reindexLinearEquiv R A e₁ e₂ ≪≫ₗ reindexLinearEquiv R A... | by
ext
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.Cycle.Type | {
"line": 589,
"column": 2
} | {
"line": 589,
"column": 30
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\ninst✝ : DecidableEq α\nσ τ : Perm α\n⊢ IsConj σ τ ↔ σ.partition = τ.partition",
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.cycleType",
"congrArg",
"Multiset",
"Fintype.card",
"id",
"DivInvMonoid.toMonoid",
"Equiv.Perm.p... | rw [isConj_iff_cycleType_eq] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Perm.Cycle.Type | {
"line": 783,
"column": 6
} | {
"line": 783,
"column": 33
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\ninst✝ : DecidableEq α\nx y z t : α\nh : [x, y, z, t].Nodup\n⊢ (swap x y).cycleType + (swap z t).cycleType = {2, 2}",
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.cycleType",
"congrArg",
"Multiset.instInsert",
"Equiv.swap",
"Equiv.Per... | isSwap_iff_cycleType.mp ?_, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.Multilinear.Basic | {
"line": 594,
"column": 8
} | {
"line": 595,
"column": 18
} | [
{
"pp": "case pos\nR : 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₂\nα : ι → Type u_1\ng : (i : ι) → α i → M₁ i\ninst✝¹ : Decidab... | · have : r i₀ ∈ C i₀ := by simp [C, hri₀]
rwa [hi] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.LinearAlgebra.Multilinear.Basic | {
"line": 591,
"column": 6
} | {
"line": 596,
"column": 43
} | [
{
"pp": "case pos\nR : 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₂\nα : ι → Type u_1\ng : (i : ι) → α i → M₁ i\ninst✝¹ : Decidab... | · apply Finset.mem_union_right
refine mem_piFinset.2 fun i => ?_
by_cases hi : i = i₀
· have : r i₀ ∈ C i₀ := by simp [C, hri₀]
rwa [hi]
· simp [C, hi, mem_piFinset.1 hr i] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 541,
"column": 6
} | {
"line": 541,
"column": 19
} | [
{
"pp": "case pos\nn : Type u_2\ninst✝² : DecidableEq n\ninst✝¹ : Fintype n\nR : Type v\ninst✝ : CommRing R\nA : Matrix n n R\ni : n\ns : Finset n\n_hi : i ∉ s\nih :\n ∀ {B : Matrix n n R} (c : n → R),\n (∀ i ∉ s, c i = 0) → ∀ k ∉ s, (∀ (i j : n), A i j = B i j + c i * B k j) → A.det = B.det\nB : Matrix n n... | · simp [hi'i] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.CategoryTheory.Limits.Creates | {
"line": 519,
"column": 8
} | {
"line": 519,
"column": 58
} | [
{
"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 : J ⥤ C\nF G : C ⥤ D\nh : F ≅ G\ninst✝ : CreatesLimit K F\nc : Cone (K ⋙ G)\nt : IsLimit c\n⊢ G.mapCone (liftLimit ((IsLimit.postcomposeInvEquiv (K.isoWhiskerLeft h) c).symm ... | refine (IsLimit.mapConeEquiv h ?_).uniqueUpToIso t | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.CategoryTheory.Limits.Types.ColimitType | {
"line": 227,
"column": 15
} | {
"line": 231,
"column": 12
} | [
{
"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",
"CategoryTheory.Functor.ιCo... | by
convert Function.Bijective.comp e.bijective hc.bijective
ext y
obtain ⟨j, x, rfl⟩ := F.ιColimitType_jointly_surjective y
simp_all | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 646,
"column": 8
} | {
"line": 646,
"column": 19
} | [
{
"pp": "case fst\nn : Type u_2\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\nR : Type v\ninst✝² : CommRing R\no : Type u_3\ninst✝¹ : Fintype o\ninst✝ : DecidableEq o\nM : o → Matrix n n R\npreserving_snd : Finset (Perm (n × o)) := ⋯\nmem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o),... | · simp only | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Category.MonCat.Limits | {
"line": 185,
"column": 6
} | {
"line": 185,
"column": 58
} | [
{
"pp": "case h.refine_1.h.e_6.h.e_val\nJ : Type v\ninst✝¹ : Category.{w, v} J\nF : J ⥤ MonCat\ninst✝ : Small.{u, max u v} ↑(F ⋙ forget MonCat).sections\nc : Cone (F ⋙ forget MonCat)\nt : IsLimit c\nthis : Small.{u, max u v} ↑(F ⋙ forget MonCat).sections\ns✝ : Cone F\nx y : ↑s✝.1\n⊢ (fun j ↦ (ConcreteCategory.h... | simp only [Functor.comp_obj, Equiv.symm_apply_apply] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Types.Filtered | {
"line": 127,
"column": 2
} | {
"line": 134,
"column": 92
} | [
{
"pp": "J : Type v\ninst✝¹ : Category.{w, v} J\nF : J ⥤ Type u\ninst✝ : IsFilteredOrEmpty J\nt : Cocone F\nht : IsColimit t\ni j : J\nxi : F.obj i\nxj : F.obj j\n⊢ t.ι.app i xi = t.ι.app j xj ↔ ∃ k f g, F.map f xi = F.map g xj",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Functor",
"Equi... | have : HasColimit F := ⟨_, ht⟩
refine Iff.trans ?_ (colimit_eq_iff_aux F)
rw [← (IsColimit.coconePointUniqueUpToIso ht (colimitCoconeIsColimit F)).toEquiv.injective.eq_iff]
convert Iff.rfl
· exact (congrFun
(IsColimit.comp_coconePointUniqueUpToIso_hom ht (colimitCoconeIsColimit F) _) xi).symm
· exact (c... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Types.Filtered | {
"line": 127,
"column": 2
} | {
"line": 134,
"column": 92
} | [
{
"pp": "J : Type v\ninst✝¹ : Category.{w, v} J\nF : J ⥤ Type u\ninst✝ : IsFilteredOrEmpty J\nt : Cocone F\nht : IsColimit t\ni j : J\nxi : F.obj i\nxj : F.obj j\n⊢ t.ι.app i xi = t.ι.app j xj ↔ ∃ k f g, F.map f xi = F.map g xj",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Functor",
"Equi... | have : HasColimit F := ⟨_, ht⟩
refine Iff.trans ?_ (colimit_eq_iff_aux F)
rw [← (IsColimit.coconePointUniqueUpToIso ht (colimitCoconeIsColimit F)).toEquiv.injective.eq_iff]
convert Iff.rfl
· exact (congrFun
(IsColimit.comp_coconePointUniqueUpToIso_hom ht (colimitCoconeIsColimit F) _) xi).symm
· exact (c... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Category.Grp.Limits | {
"line": 458,
"column": 16
} | {
"line": 463,
"column": 8
} | [
{
"pp": "J : Type v\ninst✝ : Category.{w, v} J\nG H : AddCommGrpCat\nf : G ⟶ H\n⊢ ofHom { toFun := fun g ↦ ⟨(ConcreteCategory.hom (kernel.ι f)) g, ⋯⟩, map_zero' := ⋯, map_add' := ⋯ } ≫\n kernel.lift f (ofHom (Hom.hom f).ker.subtype) ⋯ =\n 𝟙 (kernel f)",
"usedConstants": [
"CategoryTheory.Cate... | by
-- Porting note (https://github.com/leanprover-community/mathlib4/issues/11041): it would be nice to do the next two steps by a single `ext`,
-- but this will require thinking carefully about the relative priorities of `@[ext]` lemmas.
refine equalizer.hom_ext ?_
ext
simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Adjunction.FullyFaithful | {
"line": 215,
"column": 2
} | {
"line": 216,
"column": 45
} | [
{
"pp": "case mp\nC : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\nL : C ⥤ D\nR : D ⥤ C\nh : L ⊣ R\ninst✝¹ : L.Faithful\ninst✝ : L.Full\nX : D\n⊢ IsIso (h.counit.app X) → L.essImage X",
"usedConstants": [
"CategoryTheory.IsIso",
"CategoryTheory.Functor.comp",... | · intro
exact ⟨R.obj X, ⟨asIso (h.counit.app X)⟩⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.CategoryTheory.Monoidal.Category | {
"line": 386,
"column": 37
} | {
"line": 387,
"column": 61
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : MonoidalCategory C\nX Y : C\nf : X ⟶ Y\ninst✝ : IsIso f\nZ : C\n⊢ f ▷ Z ≫ inv f ▷ Z = 𝟙 (X ⊗ Z)",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Category... | by
rw [← comp_whiskerRight, IsIso.hom_inv_id, id_whiskerRight] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Monoidal.Preadditive | {
"line": 375,
"column": 13
} | {
"line": 378,
"column": 10
} | [
{
"pp": "C : Type u_1\ninst✝⁵ : Category.{v_1, u_1} C\ninst✝⁴ : Preadditive C\ninst✝³ : MonoidalCategory C\ninst✝² : MonoidalPreadditive C\ninst✝¹ : HasFiniteBiproducts C\nJ : Type\ninst✝ : Finite J\nf : J → C\nX Y Z : C\ng h : X ⟶ ((⨁ f) ⊗ Y) ⊗ Z\nw : ∀ (j : J), g ≫ biproduct.π f j ▷ Y ▷ Z = h ≫ biproduct.π f ... | by
apply (cancel_mono (α_ _ _ _).hom).mp
ext
simp [w] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Tactic.CategoryTheory.Monoidal.Normalize | {
"line": 213,
"column": 2
} | {
"line": 213,
"column": 43
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : MonoidalCategory C\nf f' g g' h i : C\nα : f ≅ g\nβ : f' ≅ g'\nη : g' ⟶ h\nηs : h ⟶ i\nη₁ : g ⊗ g' ⟶ g ⊗ h\nηs₁ : g ⊗ h ⟶ g ⊗ i\nη₂ : g ⊗ g' ⟶ g ⊗ i\nη₃ : f ⊗ f' ⟶ g ⊗ i\ne_η₁ : g ◁ ((Iso.refl g').hom ≫ η ≫ (Iso.refl h).hom) = η₁\ne_ηs₁ : g ◁ ηs = ηs₁\ne_... | simp_all [MonoidalCategory.tensorHom_def] | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Tactic.CategoryTheory.Monoidal.Normalize | {
"line": 213,
"column": 2
} | {
"line": 213,
"column": 43
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : MonoidalCategory C\nf f' g g' h i : C\nα : f ≅ g\nβ : f' ≅ g'\nη : g' ⟶ h\nηs : h ⟶ i\nη₁ : g ⊗ g' ⟶ g ⊗ h\nηs₁ : g ⊗ h ⟶ g ⊗ i\nη₂ : g ⊗ g' ⟶ g ⊗ i\nη₃ : f ⊗ f' ⟶ g ⊗ i\ne_η₁ : g ◁ ((Iso.refl g').hom ≫ η ≫ (Iso.refl h).hom) = η₁\ne_ηs₁ : g ◁ ηs = ηs₁\ne_... | simp_all [MonoidalCategory.tensorHom_def] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.CategoryTheory.Monoidal.Normalize | {
"line": 213,
"column": 2
} | {
"line": 213,
"column": 43
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : MonoidalCategory C\nf f' g g' h i : C\nα : f ≅ g\nβ : f' ≅ g'\nη : g' ⟶ h\nηs : h ⟶ i\nη₁ : g ⊗ g' ⟶ g ⊗ h\nηs₁ : g ⊗ h ⟶ g ⊗ i\nη₂ : g ⊗ g' ⟶ g ⊗ i\nη₃ : f ⊗ f' ⟶ g ⊗ i\ne_η₁ : g ◁ ((Iso.refl g').hom ≫ η ≫ (Iso.refl h).hom) = η₁\ne_ηs₁ : g ◁ ηs = ηs₁\ne_... | simp_all [MonoidalCategory.tensorHom_def] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Coalgebra.TensorProduct | {
"line": 239,
"column": 6
} | {
"line": 239,
"column": 55
} | [
{
"pp": "case a.h.h\nR✝ : Type u_1\nS✝ : Type u_2\nA : Type u_3\nB : Type u_4\ninst✝²⁷ : CommSemiring R✝\ninst✝²⁶ : CommSemiring S✝\ninst✝²⁵ : AddCommMonoid A\ninst✝²⁴ : AddCommMonoid B\ninst✝²³ : Algebra R✝ S✝\ninst✝²² : Module R✝ A\ninst✝²¹ : Module S✝ A\ninst✝²⁰ : Module R✝ B\ninst✝¹⁹ : IsScalarTower R✝ S✝ A... | hopf_tensor_induction comul (R := R) x with x₁ x₂ | TensorProduct._aux_Mathlib_RingTheory_Coalgebra_TensorProduct___macroRules_TensorProduct_tacticHopf_tensor_induction_With___1 | TensorProduct.tacticHopf_tensor_induction_With__ |
Mathlib.Order.Heyting.Hom | {
"line": 156,
"column": 8
} | {
"line": 156,
"column": 50
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\nδ : Type u_5\ninst✝² : EquivLike F α β\ninst✝¹ : CoheytingAlgebra α\nx✝ : CoheytingAlgebra β\ninst✝ : OrderIsoClass F α β\nf : F\na b : α\nc : β\n⊢ f (a \\ b) ≤ c ↔ f a \\ f b ≤ c",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatti... | simp only [← le_map_inv_iff, sdiff_le_iff] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Order.Heyting.Hom | {
"line": 171,
"column": 8
} | {
"line": 171,
"column": 50
} | [
{
"pp": "F : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\nδ : Type u_5\ninst✝² : EquivLike F α β\ninst✝¹ : BiheytingAlgebra α\nx✝ : BiheytingAlgebra β\ninst✝ : OrderIsoClass F α β\nf : F\na b : α\nc : β\n⊢ f (a \\ b) ≤ c ↔ f a \\ f b ≤ c",
"usedConstants": [
"BiheytingAlgebra.toSDiff",
"E... | simp only [← le_map_inv_iff, sdiff_le_iff] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Category.Ring.Colimits | {
"line": 232,
"column": 22
} | {
"line": 232,
"column": 86
} | [
{
"pp": "case a.map\nJ : Type v\ninst✝ : SmallCategory J\nF : J ⥤ RingCat\ns : Cocone F\nx✝ y : Prequotient F\nj j' : J\nf : j ⟶ j'\nx : ↑(F.obj j)\n⊢ descFunLift F s (Prequotient.of j' ((ConcreteCategory.hom (F.map f)) x)) = descFunLift F s (Prequotient.of j x)",
"usedConstants": [
"CategoryTheory.Fu... | exact RingHom.congr_fun (congrArg Hom.hom <| s.ι.naturality f) x | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Category.Ring.Colimits | {
"line": 232,
"column": 22
} | {
"line": 232,
"column": 86
} | [
{
"pp": "case a.map\nJ : Type v\ninst✝ : SmallCategory J\nF : J ⥤ RingCat\ns : Cocone F\nx✝ y : Prequotient F\nj j' : J\nf : j ⟶ j'\nx : ↑(F.obj j)\n⊢ descFunLift F s (Prequotient.of j' ((ConcreteCategory.hom (F.map f)) x)) = descFunLift F s (Prequotient.of j x)",
"usedConstants": [
"CategoryTheory.Fu... | exact RingHom.congr_fun (congrArg Hom.hom <| s.ι.naturality f) x | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Category.Ring.Colimits | {
"line": 232,
"column": 22
} | {
"line": 232,
"column": 86
} | [
{
"pp": "case a.map\nJ : Type v\ninst✝ : SmallCategory J\nF : J ⥤ RingCat\ns : Cocone F\nx✝ y : Prequotient F\nj j' : J\nf : j ⟶ j'\nx : ↑(F.obj j)\n⊢ descFunLift F s (Prequotient.of j' ((ConcreteCategory.hom (F.map f)) x)) = descFunLift F s (Prequotient.of j x)",
"usedConstants": [
"CategoryTheory.Fu... | exact RingHom.congr_fun (congrArg Hom.hom <| s.ι.naturality f) x | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Category.Ring.Colimits | {
"line": 251,
"column": 4
} | {
"line": 251,
"column": 27
} | [
{
"pp": "case a.left_distrib\nJ : Type v\ninst✝ : SmallCategory J\nF : J ⥤ RingCat\ns : Cocone F\nx✝ y✝ x y z : Prequotient F\n⊢ descFunLift F s (x.mul (y.add z)) = descFunLift F s ((x.mul y).add (x.mul z))",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"HMul.hMul",
"Ring... | | left_distrib x y z => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Algebra.Category.Ring.Colimits | {
"line": 530,
"column": 22
} | {
"line": 530,
"column": 86
} | [
{
"pp": "case a.map\nJ : Type v\ninst✝ : SmallCategory J\nF : J ⥤ CommRingCat\ns : Cocone F\nx✝ y : Prequotient F\nj j' : J\nf : j ⟶ j'\nx : ↑(F.obj j)\n⊢ descFunLift F s (Prequotient.of j' ((ConcreteCategory.hom (F.map f)) x)) = descFunLift F s (Prequotient.of j x)",
"usedConstants": [
"CategoryTheor... | exact RingHom.congr_fun (congrArg Hom.hom <| s.ι.naturality f) x | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Category.Ring.Colimits | {
"line": 530,
"column": 22
} | {
"line": 530,
"column": 86
} | [
{
"pp": "case a.map\nJ : Type v\ninst✝ : SmallCategory J\nF : J ⥤ CommRingCat\ns : Cocone F\nx✝ y : Prequotient F\nj j' : J\nf : j ⟶ j'\nx : ↑(F.obj j)\n⊢ descFunLift F s (Prequotient.of j' ((ConcreteCategory.hom (F.map f)) x)) = descFunLift F s (Prequotient.of j x)",
"usedConstants": [
"CategoryTheor... | exact RingHom.congr_fun (congrArg Hom.hom <| s.ι.naturality f) x | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Category.Ring.Colimits | {
"line": 530,
"column": 22
} | {
"line": 530,
"column": 86
} | [
{
"pp": "case a.map\nJ : Type v\ninst✝ : SmallCategory J\nF : J ⥤ CommRingCat\ns : Cocone F\nx✝ y : Prequotient F\nj j' : J\nf : j ⟶ j'\nx : ↑(F.obj j)\n⊢ descFunLift F s (Prequotient.of j' ((ConcreteCategory.hom (F.map f)) x)) = descFunLift F s (Prequotient.of j x)",
"usedConstants": [
"CategoryTheor... | exact RingHom.congr_fun (congrArg Hom.hom <| s.ι.naturality f) x | 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.