From afb2e8db724829aa0ab2f2b8568060d42057e3e2 Mon Sep 17 00:00:00 2001 From: Dagur Asgeirsson Date: Mon, 27 Apr 2026 13:55:51 -0600 Subject: [PATCH 1/6] feat: add concrete category boilerplate command --- .../CategoryTheory/MkConcreteCategory.lean | 108 ++++++++++++++++ MathlibTest/MkConcreteCategory.lean | 117 ++++++++++++++++++ 2 files changed, 225 insertions(+) create mode 100644 Mathlib/Tactic/CategoryTheory/MkConcreteCategory.lean create mode 100644 MathlibTest/MkConcreteCategory.lean diff --git a/Mathlib/Tactic/CategoryTheory/MkConcreteCategory.lean b/Mathlib/Tactic/CategoryTheory/MkConcreteCategory.lean new file mode 100644 index 00000000000000..d7596d40f5a1d6 --- /dev/null +++ b/Mathlib/Tactic/CategoryTheory/MkConcreteCategory.lean @@ -0,0 +1,108 @@ +/- +Copyright (c) 2026 Dagur Asgeirsson. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Dagur Asgeirsson +-/ +module + +public import Mathlib.CategoryTheory.ConcreteCategory.Basic + +/-! +# The `mk_concrete_category` command + +`mk_concrete_category C FC id comp` generates the standard initial boilerplate for a concrete +category whose morphisms are modeled by a bundled function type `FC`. + +It creates a wrapper morphism structure `Hom`, a `Category` instance, a `ConcreteCategory` +instance, the public constructor `ofHom`, the projection abbreviation `Hom.hom`, and the basic +`dsimp`/round-trip lemmas. +-/ + +open Lean Elab Command +open CategoryTheory + +namespace Mathlib.Tactic.CategoryTheory + +/-- +`mk_concrete_category C FC id comp` generates the standard boilerplate for a concrete category on +`C` whose underlying bundled hom type is `FC : C → C → Type*`, with identities given by `id` and +composition given by `comp`. + +The command is intended to be used in the namespace of `C`. It creates declarations named `Hom`, +`Hom.hom`, `ofHom`, `hom_id`, `hom_comp`, `hom_ofHom`, and `ofHom_hom`. +-/ +syntax (name := mkConcreteCategory) "mk_concrete_category " term:max ppSpace term:max ppSpace + term:max ppSpace term:max : command + +/-- Elaborator for `mk_concrete_category`. -/ +@[command_elab mkConcreteCategory] +public meta def elabMkConcreteCategory : CommandElab := fun stx => do + let `(mk_concrete_category $cat $FC $idTerm $compTerm) := stx + | throwUnsupportedSyntax + + elabCommand <| ← set_option hygiene false in `(command| + set_option backward.privateInPublic true in + /-- The type of morphisms in this concrete category. -/ + @[ext] + structure Hom (X Y : $cat) where + private mk :: + /-- The underlying bundled morphism. -/ + hom' : ($FC:term) X Y) + + elabCommand <| ← set_option hygiene false in `(command| + set_option backward.privateInPublic true in + set_option backward.privateInPublic.warn false in + instance : CategoryTheory.Category $cat where + Hom X Y := Hom X Y + id X := ⟨($idTerm:term) X⟩ + comp f g := ⟨($compTerm:term) f.hom' g.hom'⟩) + + elabCommand <| ← set_option hygiene false in `(command| + set_option backward.privateInPublic true in + set_option backward.privateInPublic.warn false in + instance : CategoryTheory.ConcreteCategory $cat $FC where + hom := Hom.hom' + ofHom := Hom.mk + id_apply := by intros; rfl + comp_apply := by intros; rfl) + + elabCommand <| ← set_option hygiene false in `(command| + /-- Turn a categorical morphism back into its underlying bundled morphism. -/ + abbrev Hom.hom {X Y : $cat} (f : Hom X Y) := + CategoryTheory.ConcreteCategory.hom (C := $cat) f) + + elabCommand <| ← set_option hygiene false in `(command| + /-- Typecheck a bundled morphism as a morphism in this concrete category. -/ + abbrev ofHom {X Y : $cat} (f : CategoryTheory.ToHom X Y) : X ⟶ Y := + CategoryTheory.ConcreteCategory.ofHom (C := $cat) f) + + elabCommand <| ← set_option hygiene false in `(command| + /-- Use the `ConcreteCategory.hom` projection for `@[simps]` lemmas. -/ + def Hom.Simps.hom (X Y : $cat) (f : Hom X Y) := + f.hom) + + elabCommand <| ← set_option hygiene false in `(command| + initialize_simps_projections Hom (hom' → hom)) + + elabCommand <| ← set_option hygiene false in `(command| + @[simp] + lemma hom_id {X : $cat} : (𝟙 X : X ⟶ X).hom = (($idTerm) X) := + rfl) + + elabCommand <| ← set_option hygiene false in `(command| + @[simp] + lemma hom_comp {X Y Z : $cat} (f : X ⟶ Y) (g : Y ⟶ Z) : + (f ≫ g).hom = (($compTerm) f.hom g.hom) := + rfl) + + elabCommand <| ← set_option hygiene false in `(command| + @[simp] + lemma hom_ofHom {X Y : $cat} (f : CategoryTheory.ToHom X Y) : (ofHom f).hom = f := + rfl) + + elabCommand <| ← set_option hygiene false in `(command| + @[simp] + lemma ofHom_hom {X Y : $cat} (f : X ⟶ Y) : ofHom f.hom = f := + rfl) + +end Mathlib.Tactic.CategoryTheory diff --git a/MathlibTest/MkConcreteCategory.lean b/MathlibTest/MkConcreteCategory.lean new file mode 100644 index 00000000000000..417fc1e516e57f --- /dev/null +++ b/MathlibTest/MkConcreteCategory.lean @@ -0,0 +1,117 @@ +/- +Copyright (c) 2026 Dagur Asgeirsson. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Dagur Asgeirsson +-/ +module + +import Mathlib.Tactic.CategoryTheory.MkConcreteCategory + +open CategoryTheory + +universe u + +/-- A tiny test category whose morphisms are wrappers around functions. -/ +structure TestCat where + /-- The underlying type. -/ + α : Type u + +namespace TestCat + +@[ext] +structure Fun (X Y : TestCat.{u}) where + toFun : X.α → Y.α + +instance (X Y : TestCat.{u}) : FunLike (Fun X Y) X.α Y.α where + coe := Fun.toFun + coe_injective' _ _ _ := by aesop + +protected def Fun.id (X : TestCat.{u}) : Fun X X where + toFun := id + +protected def Fun.comp {X Y Z : TestCat.{u}} (f : Fun X Y) (g : Fun Y Z) : Fun X Z where + toFun := g.toFun ∘ f.toFun + +mk_concrete_category TestCat Fun (Fun.id) (Fun.comp) + +/-- info: TestCat.Hom.{u_1} (X Y : TestCat) : Type u_1 -/ +#guard_msgs in +#check Hom + +/-- info: TestCat.Hom.mk.{u_1} {X Y : TestCat} (hom' : X.Fun Y) : X.Hom Y -/ +#guard_msgs in +#check Hom.mk + +/-- info: TestCat.Hom.hom'.{u_1} {X Y : TestCat} (self : X.Hom Y) : X.Fun Y -/ +#guard_msgs in +#check Hom.hom' + +/-- info: TestCat.Hom.ext.{u_1} {X Y : TestCat} {x y : X.Hom Y} (hom' : x.hom' = y.hom') : x = y -/ +#guard_msgs in +#check Hom.ext + +/-- info: inferInstance : Category.{u_1, u_1 + 1} TestCat -/ +#guard_msgs in +#check (inferInstance : Category TestCat) + +/-- info: inferInstance : ConcreteCategory TestCat Fun -/ +#guard_msgs in +#check (inferInstance : ConcreteCategory TestCat Fun) + +/-- info: TestCat.Hom.hom.{u_1} {X Y : TestCat} (f : X.Hom Y) : X.Fun Y -/ +#guard_msgs in +#check Hom.hom + +/-- info: TestCat.ofHom.{u_1} {X Y : TestCat} (f : ToHom X Y) : X ⟶ Y -/ +#guard_msgs in +#check ofHom + +/-- info: TestCat.Hom.Simps.hom.{u_1} (X Y : TestCat) (f : X.Hom Y) : X.Fun Y -/ +#guard_msgs in +#check Hom.Simps.hom + +/-- info: TestCat.hom_id.{u_1} {X : TestCat} : Hom.hom (𝟙 X) = Fun.id X -/ +#guard_msgs in +#check hom_id + +/-- info: TestCat.hom_comp.{u_1} {X Y Z : TestCat} (f : X ⟶ Y) (g : Y ⟶ Z) : Hom.hom (f ≫ g) = (Hom.hom f).comp (Hom.hom g) -/ +#guard_msgs in +#check hom_comp + +/-- info: TestCat.hom_ofHom.{u_1} {X Y : TestCat} (f : ToHom X Y) : Hom.hom (ofHom f) = f -/ +#guard_msgs in +#check hom_ofHom + +/-- info: TestCat.ofHom_hom.{u_1} {X Y : TestCat} (f : X ⟶ Y) : ofHom (Hom.hom f) = f -/ +#guard_msgs in +#check ofHom_hom + +example : Category TestCat := inferInstance + +example : ConcreteCategory TestCat Fun := inferInstance + +example {X Y : TestCat} (f : X ⟶ Y) : f.hom = ConcreteCategory.hom f := rfl + +example {X Y : TestCat} (f : Fun X Y) : (ofHom f).hom = f := by + dsimp + +example {X Y : TestCat} (f : X ⟶ Y) : ofHom f.hom = f := by + dsimp + +example {X : TestCat} : (𝟙 X : X ⟶ X).hom = Fun.id X := by + dsimp + +example {X Y Z : TestCat} (f : X ⟶ Y) (g : Y ⟶ Z) : + (f ≫ g).hom = Fun.comp f.hom g.hom := by + dsimp + +example {X Y : TestCat} (f g : X ⟶ Y) (h : f.hom = g.hom) : f = g := + Hom.ext h + +example {X Y : TestCat} (f g : X ⟶ Y) (h : ∀ x, f x = g x) : f = g := by + cat_disch + +example {X Y : TestCat} (f : Fun X Y) (x : X.α) : ofHom f x = f x := by + dsimp + +end TestCat From b000f35388c7e8b19cc3873d0c7920f7d8b18dbb Mon Sep 17 00:00:00 2001 From: Dagur Asgeirsson Date: Mon, 27 Apr 2026 13:58:53 -0600 Subject: [PATCH 2/6] . --- MathlibTest/MkConcreteCategory.lean | 1 + 1 file changed, 1 insertion(+) diff --git a/MathlibTest/MkConcreteCategory.lean b/MathlibTest/MkConcreteCategory.lean index 417fc1e516e57f..60f39ad6ae1c31 100644 --- a/MathlibTest/MkConcreteCategory.lean +++ b/MathlibTest/MkConcreteCategory.lean @@ -115,3 +115,4 @@ example {X Y : TestCat} (f : Fun X Y) (x : X.α) : ofHom f x = f x := by dsimp end TestCat +-- From df320f01e4ed6d804b900fd9a5367919f12f55f8 Mon Sep 17 00:00:00 2001 From: Dagur Asgeirsson Date: Mon, 27 Apr 2026 14:00:04 -0600 Subject: [PATCH 3/6] mk_all --- Mathlib.lean | 1 + Mathlib/Tactic.lean | 1 + MathlibTest/MkConcreteCategory.lean | 1 - 3 files changed, 2 insertions(+), 1 deletion(-) diff --git a/Mathlib.lean b/Mathlib.lean index 0b76f62837981e..1d80a483e01966 100644 --- a/Mathlib.lean +++ b/Mathlib.lean @@ -6986,6 +6986,7 @@ public import Mathlib.Tactic.CategoryTheory.Coherence.Normalize public import Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence public import Mathlib.Tactic.CategoryTheory.Elementwise public import Mathlib.Tactic.CategoryTheory.IsoReassoc +public import Mathlib.Tactic.CategoryTheory.MkConcreteCategory public import Mathlib.Tactic.CategoryTheory.Monoidal.Basic public import Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes public import Mathlib.Tactic.CategoryTheory.Monoidal.Normalize diff --git a/Mathlib/Tactic.lean b/Mathlib/Tactic.lean index d66d693ade5d3d..44e29f901000b6 100644 --- a/Mathlib/Tactic.lean +++ b/Mathlib/Tactic.lean @@ -39,6 +39,7 @@ public import Mathlib.Tactic.CategoryTheory.Coherence.Normalize public import Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence public import Mathlib.Tactic.CategoryTheory.Elementwise public import Mathlib.Tactic.CategoryTheory.IsoReassoc +public import Mathlib.Tactic.CategoryTheory.MkConcreteCategory public import Mathlib.Tactic.CategoryTheory.Monoidal.Basic public import Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes public import Mathlib.Tactic.CategoryTheory.Monoidal.Normalize diff --git a/MathlibTest/MkConcreteCategory.lean b/MathlibTest/MkConcreteCategory.lean index 60f39ad6ae1c31..417fc1e516e57f 100644 --- a/MathlibTest/MkConcreteCategory.lean +++ b/MathlibTest/MkConcreteCategory.lean @@ -115,4 +115,3 @@ example {X Y : TestCat} (f : Fun X Y) (x : X.α) : ofHom f x = f x := by dsimp end TestCat --- From 1d34ac7d6f8f4484c6b3c1ee6cf7d7753a629548 Mon Sep 17 00:00:00 2001 From: Dagur Asgeirsson Date: Mon, 27 Apr 2026 14:16:56 -0600 Subject: [PATCH 4/6] autogenerate TypeCat --- Mathlib/CategoryTheory/Types/Basic.lean | 119 ++++++------------------ 1 file changed, 27 insertions(+), 92 deletions(-) diff --git a/Mathlib/CategoryTheory/Types/Basic.lean b/Mathlib/CategoryTheory/Types/Basic.lean index 729b37e39ca156..d4215b828d2054 100644 --- a/Mathlib/CategoryTheory/Types/Basic.lean +++ b/Mathlib/CategoryTheory/Types/Basic.lean @@ -10,6 +10,7 @@ public import Mathlib.CategoryTheory.EpiMono public import Mathlib.Data.Set.CoeSort public import Mathlib.Tactic.PPWithUniv public import Mathlib.Tactic.ToAdditive +public import Mathlib.Tactic.CategoryTheory.MkConcreteCategory /-! # The category `Type`. @@ -75,7 +76,7 @@ def Fun.id (X : Type*) : Fun X X := Fun.mk _root_.id /-- Composition of `Fun`s. -/ @[simps! +dsimpLhs] -def Fun.comp {X Y Z : Type*} (f : Fun Y Z) (g : Fun X Y) : Fun X Z := mk (f.toFun ∘ g.toFun) +def Fun.comp {X Y Z : Type*} (g : Fun X Y) (f : Fun Y Z) : Fun X Z := mk (f.toFun ∘ g.toFun) /-- The equivalence between `Fun`s and functions between types. -/ def Fun.homEquiv (X Y : Type u) : (Fun X Y) ≃ (X → Y) where @@ -84,35 +85,14 @@ def Fun.homEquiv (X Y : Type u) : (Fun X Y) ≃ (X → Y) where left_inv := by intro; rfl right_inv := by intro; rfl -/-- The type of morphisms in `Type`. -/ -@[ext] -structure Hom (X Y : Type u) where - private mk :: - /-- The underlying function -/ - hom' : Fun X Y +open CategoryTheory + +mk_concrete_category (Type u) Fun (Fun.id) (Fun.comp) end TypeCat open TypeCat CategoryTheory -set_option backward.privateInPublic true in -@[to_additive_do_translate] -- Expressions involving this instance can still be additivized. -instance CategoryTheory.types : Category.{u} (Type u) where - Hom := Hom - id X := .mk <| .id X - comp f g := .mk <| g.hom'.comp f.hom' - -set_option backward.privateInPublic true in -set_option backward.privateInPublic.warn false in -/-- -The concrete category instance on `Type u`. - -Note: sometimes one needs to specify explicitly `(CC := fun X ↦ X)` to help typeclass inference. --/ -instance : ConcreteCategory.{u} (Type u) Fun where - hom := Hom.hom' - ofHom := Hom.mk - example (X Y : Type u) (f : X ⟶ Y) : (f : X → Y) = (ConcreteCategory.hom f : X → Y) := by with_reducible rfl @@ -127,43 +107,18 @@ example (X Y : Type*) (f : Fun X Y) (x : X) : f x = (f : X → Y) x := by namespace TypeCat -/-- Turn a morphism in `Type` back into a function. -/ -abbrev Hom.hom {X Y : Type u} (f : Hom X Y) : Fun X Y := - ConcreteCategory.hom (C := Type u) f - -/-- Typecheck a function as a morphism in `Type`. -/ -abbrev ofHom {X Y : Type u} (f : X → Y) : X ⟶ Y := - ConcreteCategory.ofHom (Fun.mk f) - @[inherit_doc] -scoped notation "↾" f:200 => TypeCat.ofHom f - -/-- Use the `ConcreteCategory.hom` projection for `@[simps]` lemmas. -/ -def Hom.Simps.hom (X Y : Type u) (f : X ⟶ Y) := - ConcreteCategory.hom f - -initialize_simps_projections Hom (hom' → hom) +scoped notation "↾" f:200 => TypeCat.ofHom ⟨f⟩ @[simp] -lemma Fun.toFun_apply {X Y : Type u} (f : Fun X Y) (x : X) : f.toFun x = f x := +lemma ofHom_mk {X Y : Type u} (f : X ⟶ Y) : ↾f = f := rfl -example (X : Type u) : CategoryTheory.ToType X = X := by with_reducible rfl - @[simp] -lemma ofHom_eq {X Y : Type u} (f : X ⟶ Y) : ofHom f = f := +lemma Fun.toFun_apply {X Y : Type u} (f : Fun X Y) (x : X) : f.toFun x = f x := rfl -@[simp high] -lemma hom_ofHom {X Y : Type u} (f : X → Y) : Hom.hom (ofHom f) = Fun.mk f := rfl - -@[simp] -lemma ofHom_hom {X Y : Type u} (f : X ⟶ Y) : ofHom (Hom.hom f) = f := rfl - -@[simp] -lemma ofHom_apply {X Y : Type u} (f : X → Y) (x : X) : - TypeCat.ofHom f x = f x := - rfl +example (X : Type u) : CategoryTheory.ToType X = X := by with_reducible rfl /-- `TypeCat.Hom.hom` bundled as an `Equiv`. -/ def homEquiv {X Y : Type u} : (X ⟶ Y) ≃ (X → Y) := @@ -176,7 +131,7 @@ lemma homEquiv_apply {X Y : Type u} (f : X ⟶ Y) : @[simp] lemma homEquiv_symm_apply {X Y : Type u} (f : X → Y) : - homEquiv.symm f = ofHom f := + homEquiv.symm f = ↾f := rfl lemma congr_arg {X Y : Type u} (f : X ⟶ Y) {x x' : X} (h : x = x') : f x = f x' := by @@ -186,26 +141,6 @@ end TypeCat namespace CategoryTheory -theorem types_id (X : Type u) : (𝟙 X : _ → _) = id := - rfl - -theorem types_comp {X Y Z : Type u} (f : X ⟶ Y) (g : Y ⟶ Z) : - ConcreteCategory.hom (f ≫ g) = g ∘ f := - rfl - -@[simp] -lemma types_id_apply (X : Type u) (x : X) : 𝟙 X x = x := - rfl - -@[simp] -lemma types_comp_apply {X Y Z : Type u} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) : - (f ≫ g) x = g (f x) := - rfl - -@[congr] -lemma types_congr_hom {X Y : Type u} {f g : X ⟶ Y} (h : f = g) (x : X) : f x = g x := - ConcreteCategory.congr_hom h x - @[deprecated (since := "2026-02-09")] alias hom_inv_id_apply := Iso.hom_inv_id_apply @[deprecated (since := "2026-02-09")] alias inv_hom_id_apply := Iso.inv_hom_id_apply @[deprecated (since := "2026-02-09")] alias asHom := TypeCat.ofHom @@ -237,7 +172,7 @@ variable (J) @[simps] def sectionsFunctor : (J ⥤ Type w) ⥤ Type max u w where obj F := F.sections - map {F G} φ := TypeCat.ofHom fun x ↦ ⟨fun j => φ.app j (x.1 j), fun {j j'} f => + map {F G} φ := ↾fun x ↦ ⟨fun j => φ.app j (x.1 j), fun {j j'} f => by simp [← NatTrans.naturality_apply, x.2 f]⟩ end Functor @@ -306,8 +241,8 @@ end FunctorToTypes and the original type. -/ def uliftTrivial (V : Type u) : ULift.{u} V ≅ V where - hom := ofHom fun a ↦ a.1 - inv := ofHom fun a ↦ .up a + hom := ↾fun a ↦ a.1 + inv := ↾fun a ↦ .up a /-- The functor embedding `Type u` into `Type (max u v)`. Write this as `uliftFunctor.{5, 2}` to get `Type 2 ⥤ Type 5`. @@ -315,11 +250,11 @@ Write this as `uliftFunctor.{5, 2}` to get `Type 2 ⥤ Type 5`. @[pp_with_univ, simps obj map] def uliftFunctor : Type u ⥤ Type max u v where obj X := ULift.{v} X - map {X} {_} f := ofHom fun x : ULift.{v} X => ULift.up (f x.down) + map {X} {_} f := ↾fun x : ULift.{v} X => ULift.up (f x.down) /-- `uliftFunctor : Type u ⥤ Type max u v` is fully faithful. -/ def fullyFaithfulULiftFunctor : (uliftFunctor.{v, u}).FullyFaithful where - preimage f := ofHom fun x ↦ (f (ULift.up x)).down + preimage f := ↾fun x ↦ (f (ULift.up x)).down instance uliftFunctor_full : (uliftFunctor.{v, u}).Full := fullyFaithfulULiftFunctor.full @@ -335,7 +270,7 @@ def uliftFunctorTrivial : uliftFunctor.{u, u} ≅ 𝟭 _ := -- TODO We should connect this to a general story about concrete categories -- whose forgetful functor is representable. /-- Any term `x` of a type `X` corresponds to a morphism `PUnit ⟶ X`. -/ -def homOfElement {X : Type u} (x : X) : PUnit ⟶ X := ofHom fun _ => x +def homOfElement {X : Type u} (x : X) : PUnit ⟶ X := ↾fun _ => x theorem homOfElement_eq_iff {X : Type u} (x y : X) : homOfElement x = homOfElement y ↔ x = y := ⟨fun H => ConcreteCategory.congr_hom H PUnit.unit, by simp_all⟩ @@ -343,11 +278,11 @@ theorem homOfElement_eq_iff {X : Type u} (x y : X) : homOfElement x = homOfEleme /-- A morphism in `Type` is a monomorphism if and only if it is injective. -/ @[stacks 003C] theorem ofHom_mono_iff_injective {X Y : Type u} (f : X → Y) : - Mono (ofHom f) ↔ Function.Injective f := by + Mono (↾f) ↔ Function.Injective f := by constructor · intro H x x' h rw [← homOfElement_eq_iff] at h ⊢ - exact (cancel_mono (ofHom f)).mp h + exact (cancel_mono (↾f)).mp h · refine fun H => ⟨fun g g' h => ConcreteCategory.hom_ext _ _ fun x ↦ congrFun (H.comp_left ?_) x⟩ ext y @@ -364,7 +299,7 @@ theorem injective_of_mono {X Y : Type u} (f : X ⟶ Y) [hf : Mono f] : Function. /-- A morphism in `Type _` is an epimorphism if and only if it is surjective. -/ @[stacks 003C] theorem ofHom_epi_iff_surjective {X Y : Type u} (f : X → Y) : - Epi (ofHom f) ↔ Function.Surjective f := by + Epi (↾f) ↔ Function.Surjective f := by constructor · rintro ⟨H⟩ refine Function.surjective_of_right_cancellable_Prop fun g₁ g₂ hg => ?_ @@ -395,7 +330,7 @@ allows us to use these functors in category theory. -/ def ofTypeFunctor (m : Type u → Type v) [_root_.Functor m] [LawfulFunctor m] : Type u ⥤ Type v where obj x := m x - map f := ofHom (_root_.Functor.map f.hom) + map f := ↾(_root_.Functor.map f.hom) map_id := fun α => by ext X; apply id_map map_comp f g := by ext x @@ -415,8 +350,8 @@ a categorical isomorphism between those types. -/ @[simps!] def toIso (e : X ≃ Y) : X ≅ Y where - hom := ofHom fun x ↦ e x - inv := ofHom fun x ↦ e.symm x + hom := ↾fun x ↦ e x + inv := ↾fun x ↦ e.symm x @[deprecated (since := "2026-03-20")] alias toIso_hom := toIso_hom_hom_apply @[deprecated (since := "2026-03-20")] alias toIso_inv := toIso_inv_hom_apply @@ -462,14 +397,14 @@ theorem isIso_iff_bijective {X Y : Type u} (f : X ⟶ Y) : IsIso f ↔ Function. (Equiv.ofBijective f b).toIso.isIso_hom theorem bijective_iff_isIso_ofHom {X Y : Type u} (f : X → Y) : - Function.Bijective f ↔ IsIso (ofHom f) := + Function.Bijective f ↔ IsIso (↾f) := Iff.intro (fun b => (Equiv.ofBijective f b).toIso.isIso_hom) - fun _ => (asIso (ofHom f) : X ≅ Y).toEquiv.bijective + fun _ => (asIso (↾f) : X ≅ Y).toEquiv.bijective instance : SplitEpiCategory (Type u) where isSplitEpi_of_epi f hf := IsSplitEpi.mk' <| - { section_ := ofHom <| Function.surjInv <| (epi_iff_surjective f).1 hf + { section_ := ↾(Function.surjInv <| (epi_iff_surjective f).1 hf) id := by ext x exact (Function.rightInverse_surjInv <| (epi_iff_surjective f).1 hf) x } @@ -487,8 +422,8 @@ end CategoryTheory of types. -/ @[simps] def equivIsoIso {X Y : Type u} : (X ≃ Y) ≅ (X ≅ Y) where - hom := ofHom fun e ↦ e.toIso - inv := ofHom fun i ↦ i.toEquiv + hom := ↾fun e ↦ e.toIso + inv := ↾fun i ↦ i.toEquiv /-- Equivalences (between types in the same universe) are the same as (equivalent to) isomorphisms of types. -/ From 779a2aa43f52620c4f3838e79c50318843134a52 Mon Sep 17 00:00:00 2001 From: Dagur Asgeirsson Date: Mon, 27 Apr 2026 15:03:29 -0600 Subject: [PATCH 5/6] chore: use notation for TypeCat.ofHom --- Mathlib/Algebra/Category/AlgCat/Basic.lean | 6 +-- Mathlib/Algebra/Category/Grp/Adjunctions.lean | 2 +- Mathlib/Algebra/Category/Grp/Basic.lean | 8 ++-- Mathlib/Algebra/Category/Grp/Yoneda.lean | 4 +- .../Category/ModuleCat/Adjunctions.lean | 4 +- Mathlib/Algebra/Category/ModuleCat/Basic.lean | 4 +- .../Category/ModuleCat/LeftResolution.lean | 2 +- .../ModuleCat/Presheaf/ColimitFunctor.lean | 2 +- .../Category/ModuleCat/Presheaf/Free.lean | 4 +- Mathlib/Algebra/Category/ModuleCat/Semi.lean | 4 +- Mathlib/Algebra/Category/ModuleCat/Sheaf.lean | 2 +- .../Category/ModuleCat/Sheaf/Free.lean | 4 +- .../Algebra/Category/MonCat/Adjunctions.lean | 2 +- Mathlib/Algebra/Category/MonCat/Basic.lean | 8 ++-- Mathlib/Algebra/Category/MonCat/Yoneda.lean | 4 +- .../Algebra/Category/Ring/Adjunctions.lean | 4 +- Mathlib/Algebra/Category/Semigrp/Basic.lean | 8 ++-- Mathlib/AlgebraicGeometry/Scheme.lean | 2 +- .../Sites/ConstantSheaf.lean | 2 +- .../AlgebraicTopology/ExtraDegeneracy.lean | 4 +- .../AlgebraicTopology/SimplicialNerve.lean | 6 +-- .../SimplicialSet/Basic.lean | 2 +- .../SimplicialSet/Coskeletal.lean | 2 +- .../SimplicialSet/Homotopy.lean | 2 +- .../SimplicialSet/Monoidal.lean | 2 +- .../SimplicialSet/Nerve.lean | 4 +- .../SimplicialSet/NerveAdjunction.lean | 10 ++--- .../SimplicialSet/Nonempty.lean | 2 +- .../SimplicialSet/PiZero.lean | 2 +- .../SimplicialSet/Subcomplex.lean | 2 +- Mathlib/CategoryTheory/Action.lean | 2 +- Mathlib/CategoryTheory/Action/Concrete.lean | 6 +-- Mathlib/CategoryTheory/Adjunction/Limits.lean | 8 ++-- Mathlib/CategoryTheory/Category/Cat.lean | 4 +- .../Category/Cat/Adjunction.lean | 8 ++-- .../CategoryTheory/Category/Cat/Limit.lean | 4 +- Mathlib/CategoryTheory/Category/Pointed.lean | 2 +- Mathlib/CategoryTheory/Category/RelCat.lean | 6 +-- .../CategoryTheory/CodiscreteCategory.lean | 2 +- Mathlib/CategoryTheory/CofilteredSystem.lean | 4 +- .../CategoryTheory/Comma/Presheaf/Basic.lean | 22 +++++------ .../ConcreteCategory/EpiMono.lean | 4 +- .../ConcreteCategory/Forget.lean | 6 +-- Mathlib/CategoryTheory/Elements.lean | 4 +- Mathlib/CategoryTheory/Enriched/Basic.lean | 14 +++---- Mathlib/CategoryTheory/Extensive.lean | 6 +-- Mathlib/CategoryTheory/FintypeCat.lean | 6 +-- .../CategoryTheory/Functor/FunctorHom.lean | 12 +++--- Mathlib/CategoryTheory/Functor/Hom.lean | 2 +- .../Functor/KanExtension/Dense.lean | 2 +- .../Galois/Prorepresentability.lean | 4 +- Mathlib/CategoryTheory/Galois/Topology.lean | 2 +- Mathlib/CategoryTheory/Generator/Type.lean | 2 +- .../CategoryTheory/Groupoid/Grpd/Basic.lean | 2 +- .../CategoryTheory/IsomorphismClasses.lean | 2 +- Mathlib/CategoryTheory/Limits/Cones.lean | 12 +++--- .../Limits/FunctorCategory/Shapes/Images.lean | 2 +- Mathlib/CategoryTheory/Limits/HasLimits.lean | 4 +- Mathlib/CategoryTheory/Limits/IsLimit.lean | 20 +++++----- Mathlib/CategoryTheory/Limits/MonoCoprod.lean | 6 +-- Mathlib/CategoryTheory/Limits/Presheaf.lean | 6 +-- .../Limits/Shapes/ConcreteCategory.lean | 6 +-- .../Limits/Shapes/FunctorToTypes.lean | 16 ++++---- .../Limits/Shapes/Products.lean | 4 +- .../Limits/Types/Coequalizers.lean | 8 ++-- .../CategoryTheory/Limits/Types/Colimits.lean | 12 +++--- .../Limits/Types/Coproducts.lean | 26 ++++++------- .../Limits/Types/Equalizers.lean | 12 +++--- .../CategoryTheory/Limits/Types/Filtered.lean | 2 +- .../CategoryTheory/Limits/Types/Images.lean | 8 ++-- .../CategoryTheory/Limits/Types/Limits.lean | 16 ++++---- .../CategoryTheory/Limits/Types/Products.lean | 38 +++++++++---------- .../Limits/Types/Pullbacks.lean | 12 +++--- .../CategoryTheory/Limits/Types/Pushouts.lean | 6 +-- .../CategoryTheory/Limits/Types/Yoneda.lean | 8 ++-- Mathlib/CategoryTheory/Limits/Yoneda.lean | 4 +- Mathlib/CategoryTheory/Monad/Types.lean | 6 +-- .../Monoidal/Braided/Reflection.lean | 2 +- .../Monoidal/Closed/FunctorToTypes.lean | 2 +- .../CategoryTheory/Monoidal/Closed/Types.lean | 4 +- .../Monoidal/Functor/Types.lean | 4 +- Mathlib/CategoryTheory/Monoidal/Grp_.lean | 2 +- .../Monoidal/Internal/Types/Basic.lean | 6 +-- .../Monoidal/Internal/Types/Grp_.lean | 2 +- .../Monoidal/Types/Coyoneda.lean | 4 +- .../MorphismProperty/Concrete.lean | 6 +-- .../Preadditive/Injective/Basic.lean | 4 +- .../Preadditive/Projective/Basic.lean | 2 +- Mathlib/CategoryTheory/Presentable/Type.lean | 4 +- Mathlib/CategoryTheory/ShrinkYoneda.lean | 6 +-- Mathlib/CategoryTheory/Sites/Closed.lean | 2 +- .../Sites/Coherent/RegularSheaves.lean | 2 +- .../Sites/DenseSubsite/Basic.lean | 2 +- .../Sites/Descent/IsPrestack.lean | 2 +- .../Sites/EqualizerSheafCondition.lean | 4 +- .../CategoryTheory/Sites/GlobalSections.lean | 4 +- Mathlib/CategoryTheory/Sites/IsSheafFor.lean | 2 +- Mathlib/CategoryTheory/Sites/Preserves.lean | 2 +- Mathlib/CategoryTheory/Sites/Sheaf.lean | 2 +- Mathlib/CategoryTheory/Sites/SheafHom.lean | 4 +- Mathlib/CategoryTheory/Sites/Sieves.lean | 16 ++++---- .../CategoryTheory/Sites/Subcanonical.lean | 2 +- Mathlib/CategoryTheory/Sites/Subsheaf.lean | 2 +- Mathlib/CategoryTheory/Sites/Types.lean | 24 ++++++------ .../TransfiniteCompositionLifting.lean | 2 +- Mathlib/CategoryTheory/Subfunctor/Basic.lean | 6 +-- Mathlib/CategoryTheory/Subfunctor/Image.lean | 2 +- Mathlib/CategoryTheory/Subobject/Lattice.lean | 2 +- .../CategoryTheory/Subobject/Presheaf.lean | 2 +- Mathlib/CategoryTheory/Subobject/Types.lean | 6 +-- Mathlib/CategoryTheory/Topos/Sheaf.lean | 4 +- Mathlib/CategoryTheory/Types/Basic.lean | 10 ++--- Mathlib/CategoryTheory/Types/Set.lean | 2 +- Mathlib/CategoryTheory/Yoneda.lean | 34 ++++++++--------- Mathlib/Combinatorics/Hall/Basic.lean | 2 +- .../Combinatorics/SimpleGraph/Ends/Defs.lean | 2 +- .../SimpleGraph/Finsubgraph.lean | 2 +- Mathlib/Condensed/Discrete/Colimit.lean | 16 ++++---- .../Condensed/Discrete/LocallyConstant.lean | 16 ++++---- Mathlib/Condensed/Light/Functors.lean | 4 +- Mathlib/Condensed/Light/TopCatAdjunction.lean | 2 +- Mathlib/Condensed/TopCatAdjunction.lean | 2 +- Mathlib/Condensed/TopComparison.lean | 2 +- Mathlib/Control/Fold.lean | 8 ++-- Mathlib/Geometry/Manifold/Sheaf/Smooth.lean | 12 +++--- .../LocallyRingedSpace/HasColimits.lean | 4 +- .../Homological/Resolution.lean | 4 +- Mathlib/RingTheory/Invariant/Profinite.lean | 4 +- .../CompHausLike/SigmaComparison.lean | 2 +- Mathlib/Topology/Category/Compactum.lean | 4 +- .../Category/LightProfinite/Basic.lean | 2 +- .../Topology/Category/Profinite/Basic.lean | 2 +- .../Topology/Category/Profinite/Extend.lean | 2 +- Mathlib/Topology/Category/TopCat/Yoneda.lean | 4 +- Mathlib/Topology/Homotopy/Lifting.lean | 2 +- Mathlib/Topology/Sheaves/LocalPredicate.lean | 10 ++--- Mathlib/Topology/Sheaves/Points.lean | 4 +- .../Topology/Sheaves/PresheafOfFunctions.lean | 4 +- Mathlib/Topology/Sheaves/Sheafify.lean | 2 +- 139 files changed, 395 insertions(+), 395 deletions(-) diff --git a/Mathlib/Algebra/Category/AlgCat/Basic.lean b/Mathlib/Algebra/Category/AlgCat/Basic.lean index d3214a41db5eb1..85bd5f8bbbd341 100644 --- a/Mathlib/Algebra/Category/AlgCat/Basic.lean +++ b/Mathlib/Algebra/Category/AlgCat/Basic.lean @@ -192,7 +192,7 @@ set_option backward.isDefEq.respectTransparency false in def adj : free.{u} R ⊣ forget (AlgCat.{u} R) := Adjunction.mkOfHomEquiv { homEquiv := fun _ _ => - { toFun := fun f ↦ TypeCat.ofHom ((FreeAlgebra.lift _).symm f.hom) + { toFun := fun f ↦ ↾ ((FreeAlgebra.lift _).symm f.hom) invFun := fun f ↦ ofHom <| (FreeAlgebra.lift _) f left_inv := fun f ↦ by aesop right_inv := fun f ↦ by aesop } } @@ -229,8 +229,8 @@ end CategoryTheory.Iso @[simps] def algEquivIsoAlgebraIso {X Y : Type u} [Ring X] [Ring Y] [Algebra R X] [Algebra R Y] : (X ≃ₐ[R] Y) ≅ (AlgCat.of R X ≅ AlgCat.of R Y) where - hom := TypeCat.ofHom (fun e ↦ e.toAlgebraIso) - inv := TypeCat.ofHom (fun i ↦ i.toAlgEquiv) + hom := ↾ (fun e ↦ e.toAlgebraIso) + inv := ↾ (fun i ↦ i.toAlgEquiv) instance AlgCat.forget_reflects_isos : (forget (AlgCat.{u} R)).ReflectsIsomorphisms where reflects {X Y} f _ := by diff --git a/Mathlib/Algebra/Category/Grp/Adjunctions.lean b/Mathlib/Algebra/Category/Grp/Adjunctions.lean index 97a5e4e1669a2b..62021896d35ec6 100644 --- a/Mathlib/Algebra/Category/Grp/Adjunctions.lean +++ b/Mathlib/Algebra/Category/Grp/Adjunctions.lean @@ -104,7 +104,7 @@ instance : (free.{u}).PreservesMonomorphisms where ((Types.initial_iff_empty X).2 hX).some).isZero.eq_of_tgt · have hf : Function.Injective f := by rwa [← mono_iff_injective] obtain ⟨g, hg⟩ := hf.hasLeftInverse - have : IsSplitMono f := IsSplitMono.mk' { retraction := TypeCat.ofHom g } + have : IsSplitMono f := IsSplitMono.mk' { retraction := ↾ g } infer_instance end AddCommGrpCat diff --git a/Mathlib/Algebra/Category/Grp/Basic.lean b/Mathlib/Algebra/Category/Grp/Basic.lean index f9134582995abc..226d02e66db37e 100644 --- a/Mathlib/Algebra/Category/Grp/Basic.lean +++ b/Mathlib/Algebra/Category/Grp/Basic.lean @@ -544,8 +544,8 @@ end CategoryTheory.Iso in `GrpCat` -/ @[to_additive] def mulEquivIsoGroupIso {X Y : GrpCat.{u}} : (X ≃* Y) ≅ (X ≅ Y) where - hom := TypeCat.ofHom (fun e ↦ e.toGrpIso) - inv := TypeCat.ofHom (fun i ↦ i.groupIsoToMulEquiv) + hom := ↾ (fun e ↦ e.toGrpIso) + inv := ↾ (fun i ↦ i.groupIsoToMulEquiv) /-- Additive equivalences between `AddGroup`s are the same as (isomorphic to) isomorphisms in `AddGrpCat`. -/ @@ -555,8 +555,8 @@ add_decl_doc addEquivIsoAddGroupIso in `CommGrpCat`. -/ @[to_additive] def mulEquivIsoCommGroupIso {X Y : CommGrpCat.{u}} : (X ≃* Y) ≅ (X ≅ Y) where - hom := TypeCat.ofHom (fun e ↦ e.toCommGrpIso) - inv := TypeCat.ofHom (fun i ↦ i.commGroupIsoToMulEquiv) + hom := ↾ (fun e ↦ e.toCommGrpIso) + inv := ↾ (fun i ↦ i.commGroupIsoToMulEquiv) /-- Additive equivalences between `AddCommGroup`s are the same as (isomorphic to) isomorphisms in `AddCommGrpCat`. -/ diff --git a/Mathlib/Algebra/Category/Grp/Yoneda.lean b/Mathlib/Algebra/Category/Grp/Yoneda.lean index 73abdedcd1f9d8..5512be645af801 100644 --- a/Mathlib/Algebra/Category/Grp/Yoneda.lean +++ b/Mathlib/Algebra/Category/Grp/Yoneda.lean @@ -35,8 +35,8 @@ coyoneda embedding. -/] def CommGrpCat.coyonedaForget : coyoneda ⋙ (Functor.whiskeringRight _ _ _).obj (forget _) ≅ CategoryTheory.coyoneda := dsimp% NatIso.ofComponents fun X ↦ NatIso.ofComponents fun Y ↦ { - hom := TypeCat.ofHom (fun f ↦ ofHom f), - inv := TypeCat.ofHom (fun f ↦ f.hom) } + hom := ↾ (fun f ↦ ofHom f), + inv := ↾ (fun f ↦ f.hom) } /-- The Hom bifunctor sending a type `X` and a commutative group `G` to the commutative group `X → G` with pointwise operations. diff --git a/Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean b/Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean index 3365f143876356..a532bbd17478a7 100644 --- a/Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean +++ b/Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean @@ -75,8 +75,8 @@ lemma free_map_apply {X Y : Type u} (f : X ⟶ Y) (x : X) : @[simps] def freeHomEquiv {X : Type u} {M : ModuleCat.{u} R} : ((free R).obj X ⟶ M) ≃ (X ⟶ M) where - toFun φ := TypeCat.ofHom (fun x ↦ φ (freeMk x)) - invFun ψ := freeDesc (TypeCat.ofHom ψ) + toFun φ := ↾ (fun x ↦ φ (freeMk x)) + invFun ψ := freeDesc (↾ ψ) left_inv _ := by ext; simp right_inv _ := by ext; simp diff --git a/Mathlib/Algebra/Category/ModuleCat/Basic.lean b/Mathlib/Algebra/Category/ModuleCat/Basic.lean index f7f850e3d730a6..360e6228545371 100644 --- a/Mathlib/Algebra/Category/ModuleCat/Basic.lean +++ b/Mathlib/Algebra/Category/ModuleCat/Basic.lean @@ -299,8 +299,8 @@ in `ModuleCat` -/ @[simps] def linearEquivIsoModuleIso {X Y : Type u} [AddCommGroup X] [AddCommGroup Y] [Module R X] [Module R Y] : (X ≃ₗ[R] Y) ≅ (ModuleCat.of R X ≅ ModuleCat.of R Y) where - hom := TypeCat.ofHom (fun e ↦ e.toModuleIso) - inv := TypeCat.ofHom (fun i ↦ i.toLinearEquiv) + hom := ↾ (fun e ↦ e.toModuleIso) + inv := ↾ (fun i ↦ i.toLinearEquiv) end diff --git a/Mathlib/Algebra/Category/ModuleCat/LeftResolution.lean b/Mathlib/Algebra/Category/ModuleCat/LeftResolution.lean index 7816cd3c8deb06..d75936c77ed04c 100644 --- a/Mathlib/Algebra/Category/ModuleCat/LeftResolution.lean +++ b/Mathlib/Algebra/Category/ModuleCat/LeftResolution.lean @@ -34,7 +34,7 @@ instance (X : Type u) : Projective ((free R).obj X) where factors {M N} f p hp := by rw [epi_iff_surjective] at hp obtain ⟨s, hs⟩ := hp.hasRightInverse - exact ⟨freeDesc (TypeCat.ofHom (fun x ↦ s (f (freeMk x)))), by cat_disch⟩ + exact ⟨freeDesc (↾ (fun x ↦ s (f (freeMk x)))), by cat_disch⟩ set_option backward.isDefEq.respectTransparency false in /-- An `R`-module `M` can be functorially written as a quotient of a diff --git a/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean b/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean index f7849188e00576..4fef7aef258b5d 100644 --- a/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean +++ b/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean @@ -79,7 +79,7 @@ by `cR.pt` on `ModuleColimit hcR hcM`. -/ noncomputable def coconeSMul : Cocone (R ⋙ forget _ ⊗ M.presheaf ⋙ forget _) where pt := ModuleColimit hcR hcM - ι.app U := TypeCat.ofHom fun ⟨(r : R.obj U), (m : M.obj U)⟩ ↦ by exact cM.ι.app U (r • m) + ι.app U := ↾ fun ⟨(r : R.obj U), (m : M.obj U)⟩ ↦ by exact cM.ι.app U (r • m) ι.naturality V U f := by ext ⟨r, m⟩ exact (ConcreteCategory.congr_arg (cM.ι.app U) diff --git a/Mathlib/Algebra/Category/ModuleCat/Presheaf/Free.lean b/Mathlib/Algebra/Category/ModuleCat/Presheaf/Free.lean index d28546fb572b5d..79747fff209e96 100644 --- a/Mathlib/Algebra/Category/ModuleCat/Presheaf/Free.lean +++ b/Mathlib/Algebra/Category/ModuleCat/Presheaf/Free.lean @@ -41,7 +41,7 @@ of modules over `R` which sends `X : Cᵒᵖ` to the free `R.obj X`-module on `F @[simps] noncomputable def freeObj (F : Cᵒᵖ ⥤ Type u) : PresheafOfModules.{u} R where obj X := (ModuleCat.free (R.obj X)).obj (F.obj X) - map {X Y} f := ModuleCat.freeDesc (TypeCat.ofHom (fun x ↦ ModuleCat.freeMk (F.map f x))) + map {X Y} f := ModuleCat.freeDesc (↾ (fun x ↦ ModuleCat.freeMk (F.map f x))) map_id := by aesop /-- The free presheaf of modules functor `(Cᵒᵖ ⥤ Type u) ⥤ PresheafOfModules.{u} R`. -/ @@ -71,7 +71,7 @@ variable (F R) in /-- The unit of `PresheafOfModules.freeAdjunction`. -/ @[simps] noncomputable def freeAdjunctionUnit : F ⟶ (freeObj (R := R) F).presheaf ⋙ forget _ where - app X := TypeCat.ofHom (fun x ↦ ModuleCat.freeMk x) + app X := ↾ (fun x ↦ ModuleCat.freeMk x) naturality X Y f := by ext; simp [presheaf] set_option backward.isDefEq.respectTransparency false in diff --git a/Mathlib/Algebra/Category/ModuleCat/Semi.lean b/Mathlib/Algebra/Category/ModuleCat/Semi.lean index 355ffbf4e7dfec..e17e7d2924b983 100644 --- a/Mathlib/Algebra/Category/ModuleCat/Semi.lean +++ b/Mathlib/Algebra/Category/ModuleCat/Semi.lean @@ -273,8 +273,8 @@ in `SemimoduleCat` -/ def linearEquivIsoModuleIsoₛ {X Y : Type u} [AddCommMonoid X] [AddCommMonoid Y] [Module R X] [Module R Y] : (X ≃ₗ[R] Y) ≅ ((SemimoduleCat.of R X) ≅ (SemimoduleCat.of R Y)) where - hom := TypeCat.ofHom (fun e ↦ e.toModuleIsoₛ) - inv := TypeCat.ofHom (fun i ↦ i.toLinearEquivₛ) + hom := ↾ (fun e ↦ e.toModuleIsoₛ) + inv := ↾ (fun i ↦ i.toLinearEquivₛ) end diff --git a/Mathlib/Algebra/Category/ModuleCat/Sheaf.lean b/Mathlib/Algebra/Category/ModuleCat/Sheaf.lean index 0f67e863edecc5..2dd3d314b32c4b 100644 --- a/Mathlib/Algebra/Category/ModuleCat/Sheaf.lean +++ b/Mathlib/Algebra/Category/ModuleCat/Sheaf.lean @@ -150,7 +150,7 @@ variable (R) in @[simps] def sectionsFunctor : SheafOfModules.{v} R ⥤ Type _ where obj M := M.sections - map f := TypeCat.ofHom (sectionsMap f) + map f := ↾ (sectionsMap f) variable [J.HasSheafCompose (forget₂ RingCat.{u} AddCommGrpCat.{u})] diff --git a/Mathlib/Algebra/Category/ModuleCat/Sheaf/Free.lean b/Mathlib/Algebra/Category/ModuleCat/Sheaf/Free.lean index 481084aac1e0c3..8f646a5e584769 100644 --- a/Mathlib/Algebra/Category/ModuleCat/Sheaf/Free.lean +++ b/Mathlib/Algebra/Category/ModuleCat/Sheaf/Free.lean @@ -158,14 +158,14 @@ noncomputable def freeSumIso : free I ⨿ free J ≅ free (R := R) (I ⊕ J) := @[reassoc (attr := simp)] lemma inl_freeSumIso_hom : coprod.inl ≫ (freeSumIso (R := R) I J).hom = freeMap Sum.inl := by - rw [← dsimp% freeFunctor_map (TypeCat.ofHom (Sum.inl : I → I ⊕ J))] + rw [← dsimp% freeFunctor_map (↾ (Sum.inl : I → I ⊕ J))] exact IsColimit.comp_coconePointUniqueUpToIso_hom (coprodIsCoprod (free (R := R) I) (free J)) _ (.mk .left) @[reassoc (attr := simp)] lemma inr_freeSumIso_hom : coprod.inr ≫ (freeSumIso (R := R) I J).hom = freeMap Sum.inr := by - rw [← dsimp% freeFunctor_map (TypeCat.ofHom (Sum.inr : J → I ⊕ J))] + rw [← dsimp% freeFunctor_map (↾ (Sum.inr : J → I ⊕ J))] exact IsColimit.comp_coconePointUniqueUpToIso_hom (coprodIsCoprod (free (R := R) I) (free J)) _ (.mk .right) diff --git a/Mathlib/Algebra/Category/MonCat/Adjunctions.lean b/Mathlib/Algebra/Category/MonCat/Adjunctions.lean index 5326196ca78719..03bb5902e7628c 100644 --- a/Mathlib/Algebra/Category/MonCat/Adjunctions.lean +++ b/Mathlib/Algebra/Category/MonCat/Adjunctions.lean @@ -98,7 +98,7 @@ set_option backward.isDefEq.respectTransparency false in /-- The free-forgetful adjunction for commutative monoids. -/ noncomputable def adj : free ⊣ forget AddCommMonCat.{u} where - unit := { app X := TypeCat.ofHom fun i ↦ Finsupp.single i 1 } + unit := { app X := ↾ fun i ↦ Finsupp.single i 1 } counit := { app M := ofHom (Finsupp.liftAddHom (multiplesHom M)) naturality {M N} f := by ext1; apply Finsupp.liftAddHom.symm.injective; cat_disch } diff --git a/Mathlib/Algebra/Category/MonCat/Basic.lean b/Mathlib/Algebra/Category/MonCat/Basic.lean index 63580ff226d2ff..85f6b8c2ae1fd2 100644 --- a/Mathlib/Algebra/Category/MonCat/Basic.lean +++ b/Mathlib/Algebra/Category/MonCat/Basic.lean @@ -469,8 +469,8 @@ in `MonCat` -/ @[to_additive addEquivIsoAddMonCatIso] def mulEquivIsoMonCatIso {X Y : Type u} [Monoid X] [Monoid Y] : (X ≃* Y) ≅ (MonCat.of X ≅ MonCat.of Y) where - hom := TypeCat.ofHom (fun e ↦ e.toMonCatIso) - inv := TypeCat.ofHom (fun i ↦ i.monCatIsoToMulEquiv) + hom := ↾ (fun e ↦ e.toMonCatIso) + inv := ↾ (fun i ↦ i.monCatIsoToMulEquiv) /-- additive equivalences between `AddMonoid`s are the same as (isomorphic to) isomorphisms in `AddMonCat` -/ @@ -481,8 +481,8 @@ in `CommMonCat` -/ @[to_additive addEquivIsoAddCommMonCatIso] def mulEquivIsoCommMonCatIso {X Y : Type u} [CommMonoid X] [CommMonoid Y] : (X ≃* Y) ≅ (CommMonCat.of X ≅ CommMonCat.of Y) where - hom := TypeCat.ofHom (fun e ↦ e.toCommMonCatIso) - inv := TypeCat.ofHom (fun i ↦ i.commMonCatIsoToMulEquiv) + hom := ↾ (fun e ↦ e.toCommMonCatIso) + inv := ↾ (fun i ↦ i.commMonCatIsoToMulEquiv) /-- additive equivalences between `AddCommMonoid`s are the same as (isomorphic to) isomorphisms in `AddCommMonCat` -/ diff --git a/Mathlib/Algebra/Category/MonCat/Yoneda.lean b/Mathlib/Algebra/Category/MonCat/Yoneda.lean index 30fc1946230ea6..38ce6f1abbf93a 100644 --- a/Mathlib/Algebra/Category/MonCat/Yoneda.lean +++ b/Mathlib/Algebra/Category/MonCat/Yoneda.lean @@ -36,8 +36,8 @@ coyoneda embedding. -/] def CommMonCat.coyonedaForget : coyoneda ⋙ (Functor.whiskeringRight _ _ _).obj (forget _) ≅ CategoryTheory.coyoneda := dsimp% NatIso.ofComponents fun X ↦ NatIso.ofComponents fun Y ↦ { - hom := TypeCat.ofHom (fun f ↦ ofHom f) - inv := TypeCat.ofHom (fun f ↦ f.hom) } + hom := ↾ (fun f ↦ ofHom f) + inv := ↾ (fun f ↦ f.hom) } /-- The Hom bifunctor sending a type `X` and a commutative monoid `M` to the commutative monoid `X → M` with pointwise operations. diff --git a/Mathlib/Algebra/Category/Ring/Adjunctions.lean b/Mathlib/Algebra/Category/Ring/Adjunctions.lean index 0ae771a2929c44..e3ea4abb0ceb26 100644 --- a/Mathlib/Algebra/Category/Ring/Adjunctions.lean +++ b/Mathlib/Algebra/Category/Ring/Adjunctions.lean @@ -51,7 +51,7 @@ set_option backward.isDefEq.respectTransparency false in def adj : free ⊣ forget CommRingCat.{u} := Adjunction.mkOfHomEquiv { homEquiv := fun _ _ ↦ - { toFun := fun f ↦ TypeCat.ofHom (homEquiv f.hom) + { toFun := fun f ↦ ↾ (homEquiv f.hom) invFun := fun f ↦ ofHom <| homEquiv.symm f left_inv := fun f ↦ congrArg ofHom (homEquiv.left_inv f.hom) right_inv := by cat_disch } @@ -73,7 +73,7 @@ def coyoneda : Type vᵒᵖ ⥤ CommRingCat.{u} ⥤ CommRingCat.{max u v} where /-- The adjunction `Hom_{CRing}(Fun(n, R), S) ≃ Fun(n, Hom_{CRing}(R, S))`. -/ def coyonedaAdj (R : CommRingCat.{u}) : (coyoneda.flip.obj R).rightOp ⊣ yoneda.obj R where - unit := { app n := TypeCat.ofHom (fun i ↦ CommRingCat.ofHom (Pi.evalRingHom _ i)) } + unit := { app n := ↾ (fun i ↦ CommRingCat.ofHom (Pi.evalRingHom _ i)) } counit := { app S := (CommRingCat.ofHom (Pi.ringHom fun f ↦ f.hom)).op } instance (R : CommRingCat.{u}) : (yoneda.obj R).IsRightAdjoint := ⟨_, ⟨coyonedaAdj R⟩⟩ diff --git a/Mathlib/Algebra/Category/Semigrp/Basic.lean b/Mathlib/Algebra/Category/Semigrp/Basic.lean index 761484690eb0df..2917219c383771 100644 --- a/Mathlib/Algebra/Category/Semigrp/Basic.lean +++ b/Mathlib/Algebra/Category/Semigrp/Basic.lean @@ -419,8 +419,8 @@ in `MagmaCat` -/ as (isomorphic to) isomorphisms in `AddMagmaCat` -/] def mulEquivIsoMagmaIso {X Y : Type u} [Mul X] [Mul Y] : (X ≃* Y) ≅ (MagmaCat.of X ≅ MagmaCat.of Y) where - hom := TypeCat.ofHom (fun e ↦ e.toMagmaCatIso) - inv := TypeCat.ofHom (fun i ↦ i.magmaCatIsoToMulEquiv) + hom := ↾ (fun e ↦ e.toMagmaCatIso) + inv := ↾ (fun i ↦ i.magmaCatIsoToMulEquiv) /-- multiplicative equivalences between `Semigroup`s are the same as (isomorphic to) isomorphisms in `Semigroup` -/ @@ -429,8 +429,8 @@ in `Semigroup` -/ the same as (isomorphic to) isomorphisms in `AddSemigroup` -/] def mulEquivIsoSemigrpIso {X Y : Type u} [Semigroup X] [Semigroup Y] : (X ≃* Y) ≅ (Semigrp.of X ≅ Semigrp.of Y) where - hom := TypeCat.ofHom (fun e ↦ e.toSemigrpIso) - inv := TypeCat.ofHom (fun i ↦ i.semigrpIsoToMulEquiv) + hom := ↾ (fun e ↦ e.toSemigrpIso) + inv := ↾ (fun i ↦ i.semigrpIsoToMulEquiv) @[to_additive] instance MagmaCat.forgetReflectsIsos : (forget MagmaCat.{u}).ReflectsIsomorphisms where diff --git a/Mathlib/AlgebraicGeometry/Scheme.lean b/Mathlib/AlgebraicGeometry/Scheme.lean index b6e0271fb6b201..14ae2f64c78c13 100644 --- a/Mathlib/AlgebraicGeometry/Scheme.lean +++ b/Mathlib/AlgebraicGeometry/Scheme.lean @@ -350,7 +350,7 @@ unif_hint forget_obj_eq_coe (X : Scheme) where ⊢ forget.obj X ≟ (X : Type*) @[simp] lemma forget_obj (X) : Scheme.forget.obj X = X := rfl lemma forget_map' {X Y} (f : X ⟶ Y) : (forget.map f : _ → _) = f := rfl -@[simp] lemma forget_map {X Y} (f : X ⟶ Y) : forget.map f = TypeCat.ofHom f := rfl +@[simp] lemma forget_map {X Y} (f : X ⟶ Y) : forget.map f = ↾ f := rfl namespace Hom diff --git a/Mathlib/AlgebraicGeometry/Sites/ConstantSheaf.lean b/Mathlib/AlgebraicGeometry/Sites/ConstantSheaf.lean index a94470db8e8af7..0c7f865922111f 100644 --- a/Mathlib/AlgebraicGeometry/Sites/ConstantSheaf.lean +++ b/Mathlib/AlgebraicGeometry/Sites/ConstantSheaf.lean @@ -43,7 +43,7 @@ presheaf `U ↦ C(U, T)`. For universe reasons, we implement it by hand. @[simps] def continuousMapPresheaf (T : Type v) [TopologicalSpace T] : Scheme.{u}ᵒᵖ ⥤ Type (max v u) where obj U := C(U.unop, T) - map {U V} f := TypeCat.ofHom fun g ↦ ContinuousMap.comp g f.unop.base.hom + map {U V} f := ↾ fun g ↦ ContinuousMap.comp g f.unop.base.hom /-- `continuousMapPresheaf` is isomorphic to the composition of the forgetful functor to `TopCat` and the yoneda embedding. -/ diff --git a/Mathlib/AlgebraicTopology/ExtraDegeneracy.lean b/Mathlib/AlgebraicTopology/ExtraDegeneracy.lean index 658d1ef53c3eed..e7b1a2bbf456bf 100644 --- a/Mathlib/AlgebraicTopology/ExtraDegeneracy.lean +++ b/Mathlib/AlgebraicTopology/ExtraDegeneracy.lean @@ -187,8 +187,8 @@ open SSet.stdSimplex in /-- The obvious extra degeneracy on the standard simplex. -/ protected noncomputable def extraDegeneracy (Δ : SimplexCategory) : SimplicialObject.Augmented.ExtraDegeneracy (stdSimplex.obj Δ) where - s' := TypeCat.ofHom (fun _ ↦ objMk (OrderHom.const _ 0)) - s _ := TypeCat.ofHom (fun f ↦ objEquiv.symm (shift (objEquiv f))) + s' := ↾ (fun _ ↦ objMk (OrderHom.const _ 0)) + s _ := ↾ (fun f ↦ objEquiv.symm (shift (objEquiv f))) s'_comp_ε := by dsimp subsingleton diff --git a/Mathlib/AlgebraicTopology/SimplicialNerve.lean b/Mathlib/AlgebraicTopology/SimplicialNerve.lean index 4183113acee2ea..e37e3049083b20 100644 --- a/Mathlib/AlgebraicTopology/SimplicialNerve.lean +++ b/Mathlib/AlgebraicTopology/SimplicialNerve.lean @@ -122,8 +122,8 @@ attribute [local simp] types_tensorObj_def in instance (J : Type*) [LinearOrder J] : SimplicialCategory (SimplicialThickening J) where Hom i j := nerve (i ⟶ j) - id _ := ⟨fun _ ↦ TypeCat.ofHom (fun _ ↦ (Functor.const _).obj (𝟙 _)), fun _ _ _ ↦ by simp; rfl⟩ - comp i j k := ⟨fun _ ↦ TypeCat.ofHom (fun x ↦ x.1.prod' x.2 ⋙ compFunctor i j k), + id _ := ⟨fun _ ↦ ↾ (fun _ ↦ (Functor.const _).obj (𝟙 _)), fun _ _ _ ↦ by simp; rfl⟩ + comp i j k := ⟨fun _ ↦ ↾ (fun x ↦ x.1.prod' x.2 ⋙ compFunctor i j k), fun _ _ _ ↦ by simp; rfl⟩ homEquiv {i j} := nerveEquiv.symm.trans (SSet.unitHomEquiv (nerve (i ⟶ j))).symm @@ -188,7 +188,7 @@ the linear order `Fin (n + 1)` to `C` def SimplicialNerve (C : Type u) [Category.{v} C] [SimplicialCategory C] : SSet.{max u v} where obj n := EnrichedFunctor SSet (SimplicialThickening (ULift (Fin (n.unop.len + 1)))) C - map f := TypeCat.ofHom ((SimplicialThickening.functor f.unop.toOrderHom.uliftMap).comp + map f := ↾ ((SimplicialThickening.functor f.unop.toOrderHom.uliftMap).comp (E := C) SSet) map_id i := by ext diff --git a/Mathlib/AlgebraicTopology/SimplicialSet/Basic.lean b/Mathlib/AlgebraicTopology/SimplicialSet/Basic.lean index 68fa007092a11a..67d88b1e2aee46 100644 --- a/Mathlib/AlgebraicTopology/SimplicialSet/Basic.lean +++ b/Mathlib/AlgebraicTopology/SimplicialSet/Basic.lean @@ -53,7 +53,7 @@ lemma comp_app {X Y Z : SSet} (f : X ⟶ Y) (g : Y ⟶ Z) (n : SimplexCategory /-- The constant map of simplicial sets `X ⟶ Y` induced by a simplex `y : Y _[0]`. -/ @[simps] def const {X Y : SSet.{u}} (y : Y _⦋0⦌) : X ⟶ Y where - app n := TypeCat.ofHom (fun _ ↦ Y.map (n.unop.const _ 0).op y) + app n := ↾ (fun _ ↦ Y.map (n.unop.const _ 0).op y) naturality _ _ _ := by ext dsimp diff --git a/Mathlib/AlgebraicTopology/SimplicialSet/Coskeletal.lean b/Mathlib/AlgebraicTopology/SimplicialSet/Coskeletal.lean index efac59db59f6d6..a47cc1505886bd 100644 --- a/Mathlib/AlgebraicTopology/SimplicialSet/Coskeletal.lean +++ b/Mathlib/AlgebraicTopology/SimplicialSet/Coskeletal.lean @@ -181,7 +181,7 @@ open isPointwiseRightKanExtensionAt in /-- A strict Segal simplicial set is 2-coskeletal. -/ noncomputable def isPointwiseRightKanExtensionAt (n : ℕ) : (rightExtensionInclusion X 2).IsPointwiseRightKanExtensionAt ⟨⦋n⦌⟩ where - lift s := TypeCat.ofHom (fun x ↦ lift sx s x) + lift s := ↾ (fun x ↦ lift sx s x) fac s j := by ext x obtain ⟨⟨i, hi⟩, ⟨f : _ ⟶ _⟩, rfl⟩ := j.mk_surjective diff --git a/Mathlib/AlgebraicTopology/SimplicialSet/Homotopy.lean b/Mathlib/AlgebraicTopology/SimplicialSet/Homotopy.lean index f9bfeeb628bb5c..f28a6f3b36a664 100644 --- a/Mathlib/AlgebraicTopology/SimplicialSet/Homotopy.lean +++ b/Mathlib/AlgebraicTopology/SimplicialSet/Homotopy.lean @@ -67,7 +67,7 @@ set_option backward.isDefEq.respectTransparency false in morphisms of simplicial objects between `f` and `g`. -/ noncomputable def toSimplicialObjectHomotopy (H : Homotopy f g) : SimplicialObject.Homotopy f g where - h i := TypeCat.ofHom fun x ↦ + h i := ↾ fun x ↦ (yonedaEquiv.symm x ▷ Δ[1] ≫ H.h).app _ (prodStdSimplex.nonDegenerateEquiv₁ i).1 h_zero_comp_δ_zero n := by ext x diff --git a/Mathlib/AlgebraicTopology/SimplicialSet/Monoidal.lean b/Mathlib/AlgebraicTopology/SimplicialSet/Monoidal.lean index ca976b970a9e04..60b6b6661a551b 100644 --- a/Mathlib/AlgebraicTopology/SimplicialSet/Monoidal.lean +++ b/Mathlib/AlgebraicTopology/SimplicialSet/Monoidal.lean @@ -78,7 +78,7 @@ set_option backward.isDefEq.respectTransparency false in def unitHomEquiv (K : SSet.{u}) : (𝟙_ _ ⟶ K) ≃ K _⦋0⦌ where toFun φ := φ.app _ PUnit.unit invFun x := - { app := fun Δ => TypeCat.ofHom (fun _ => K.map (SimplexCategory.const Δ.unop ⦋0⦌ 0).op x) + { app := fun Δ => ↾ (fun _ => K.map (SimplexCategory.const Δ.unop ⦋0⦌ 0).op x) naturality := fun Δ Δ' f => by ext ⟨⟩ dsimp diff --git a/Mathlib/AlgebraicTopology/SimplicialSet/Nerve.lean b/Mathlib/AlgebraicTopology/SimplicialSet/Nerve.lean index 32c9b190b9e4a1..0b54e5d943e9b1 100644 --- a/Mathlib/AlgebraicTopology/SimplicialSet/Nerve.lean +++ b/Mathlib/AlgebraicTopology/SimplicialSet/Nerve.lean @@ -34,7 +34,7 @@ namespace CategoryTheory @[simps -isSimp] def nerve (C : Type u) [Category.{v} C] : SSet.{max u v} where obj Δ := ComposableArrows C (Δ.unop.len) - map f := TypeCat.ofHom fun x ↦ x.whiskerLeft (SimplexCategory.toCat.map f.unop).toFunctor + map f := ↾ fun x ↦ x.whiskerLeft (SimplexCategory.toCat.map f.unop).toFunctor -- `aesop` can prove these but is slow, help it out: map_id _ := rfl map_comp _ _ := rfl @@ -51,7 +51,7 @@ variable {C D : Type u} [Category.{v} C] [Category.{v} D] (F : C ⥤ D) /-- Given a functor `C ⥤ D`, we obtain a morphism `nerve C ⟶ nerve D` of simplicial sets. -/ @[simps -isSimp] def nerveMap {C D : Type u} [Category.{v} C] [Category.{v} D] (F : C ⥤ D) : nerve C ⟶ nerve D := - { app _ := TypeCat.ofHom (fun X ↦ (F.mapComposableArrows _).obj X) } + { app _ := ↾ (fun X ↦ (F.mapComposableArrows _).obj X) } lemma nerveMap_app_mk₀ (x : C) : (nerveMap F).app (op ⦋0⦌) (ComposableArrows.mk₀ x) = diff --git a/Mathlib/AlgebraicTopology/SimplicialSet/NerveAdjunction.lean b/Mathlib/AlgebraicTopology/SimplicialSet/NerveAdjunction.lean index bc98e434505593..e488605c247eb7 100644 --- a/Mathlib/AlgebraicTopology/SimplicialSet/NerveAdjunction.lean +++ b/Mathlib/AlgebraicTopology/SimplicialSet/NerveAdjunction.lean @@ -138,9 +138,9 @@ lemma hσ'₁ (x : X _⦋1⦌₂) : def app (n : (SimplexCategory.Truncated 2)ᵒᵖ) : X.obj n ⟶ Y.obj n := by obtain ⟨⟨n⟩, hn⟩ := n match n with - | 0 => exact TypeCat.ofHom f₀ - | 1 => exact TypeCat.ofHom f₁ - | 2 => exact TypeCat.ofHom (f₂ f₀ f₁ hδ₁ hδ₀ hY) + | 0 => exact ↾ f₀ + | 1 => exact ↾ f₁ + | 2 => exact ↾ (f₂ f₀ f₁ hδ₁ hδ₀ hY) /-- The property of morphisms in `SimplexCategory.Truncated 2` for which `liftOfStrictSegal.app` is natural. -/ @@ -182,11 +182,11 @@ def liftOfStrictSegal : X ⟶ Y where @[simp] lemma liftOfStrictSegal_app_0 : - (liftOfStrictSegal f₀ f₁ hδ₁ hδ₀ H hσ hY).app (op ⦋0⦌₂) = TypeCat.ofHom f₀ := rfl + (liftOfStrictSegal f₀ f₁ hδ₁ hδ₀ H hσ hY).app (op ⦋0⦌₂) = ↾ f₀ := rfl @[simp] lemma liftOfStrictSegal_app_1 : - (liftOfStrictSegal f₀ f₁ hδ₁ hδ₀ H hσ hY).app (op ⦋1⦌₂) = TypeCat.ofHom f₁ := rfl + (liftOfStrictSegal f₀ f₁ hδ₁ hδ₀ H hσ hY).app (op ⦋1⦌₂) = ↾ f₁ := rfl end liftOfStrictSegal diff --git a/Mathlib/AlgebraicTopology/SimplicialSet/Nonempty.lean b/Mathlib/AlgebraicTopology/SimplicialSet/Nonempty.lean index c4f013c749e9a9..6fe9da06f0edee 100644 --- a/Mathlib/AlgebraicTopology/SimplicialSet/Nonempty.lean +++ b/Mathlib/AlgebraicTopology/SimplicialSet/Nonempty.lean @@ -57,7 +57,7 @@ def isInitialOfNotNonempty (hX : ¬ X.Nonempty) : IsInitial X := by have (n : SimplexCategoryᵒᵖ) : IsEmpty (X.obj n) := Function.isEmpty (X.map (⦋0⦌.const n.unop 0).op) exact IsInitial.ofUniqueHom (fun _ ↦ - { app _ := TypeCat.ofHom fun x ↦ isEmptyElim x + { app _ := ↾ fun x ↦ isEmptyElim x naturality _ _ _ := by ext x; exact isEmptyElim x }) (fun _ _ ↦ by ext _ x; exact isEmptyElim x) diff --git a/Mathlib/AlgebraicTopology/SimplicialSet/PiZero.lean b/Mathlib/AlgebraicTopology/SimplicialSet/PiZero.lean index e9fdccbfee3bed..7ecfb462df6c6a 100644 --- a/Mathlib/AlgebraicTopology/SimplicialSet/PiZero.lean +++ b/Mathlib/AlgebraicTopology/SimplicialSet/PiZero.lean @@ -111,7 +111,7 @@ lemma mapπ₀_comp_apply (f : X ⟶ Y) (g : Y ⟶ Z) (x : π₀ X) : @[simps] def π₀Functor : SSet.{u} ⥤ Type u where obj X := π₀ X - map f := TypeCat.ofHom <| mapπ₀ f + map f := ↾(mapπ₀ f) /-- The map `π₀.mk : X _⦋0⦌ ⟶ π₀ X` for all simplicial sets `X`, as a natural transformation. -/ diff --git a/Mathlib/AlgebraicTopology/SimplicialSet/Subcomplex.lean b/Mathlib/AlgebraicTopology/SimplicialSet/Subcomplex.lean index fedc2f8526bf1b..ac57c5ab0b7e7c 100644 --- a/Mathlib/AlgebraicTopology/SimplicialSet/Subcomplex.lean +++ b/Mathlib/AlgebraicTopology/SimplicialSet/Subcomplex.lean @@ -128,7 +128,7 @@ instance : Subsingleton (((⊥ : X.Subcomplex) : SSet.{u}) ⟶ Y) where instance : Unique (((⊥ : X.Subcomplex) : SSet.{u}) ⟶ Y) where default := - { app _ := TypeCat.ofHom fun ⟨_, h⟩ ↦ by tauto + { app _ := ↾ fun ⟨_, h⟩ ↦ by tauto naturality _ _ _ := by ext ⟨_, h⟩; tauto } uniq := by subsingleton diff --git a/Mathlib/CategoryTheory/Action.lean b/Mathlib/CategoryTheory/Action.lean index 3bbae05cd26f2b..967ddcc06c4f1e 100644 --- a/Mathlib/CategoryTheory/Action.lean +++ b/Mathlib/CategoryTheory/Action.lean @@ -38,7 +38,7 @@ variable (M : Type*) [Monoid M] (X : Type u) [MulAction M X] @[simps obj map] def actionAsFunctor : SingleObj M ⥤ Type u where obj _ := X - map f := TypeCat.ofHom (f • ·) + map f := ↾ (f • ·) map_id _ := by ext; exact MulAction.one_smul _ map_comp f g := by ext x; exact (smul_smul g f x).symm diff --git a/Mathlib/CategoryTheory/Action/Concrete.lean b/Mathlib/CategoryTheory/Action/Concrete.lean index 1e8561c3d2aebe..0cd3ab0bf33e10 100644 --- a/Mathlib/CategoryTheory/Action/Concrete.lean +++ b/Mathlib/CategoryTheory/Action/Concrete.lean @@ -33,7 +33,7 @@ instance (X : Type u) : CoeFun (End X) (fun _ ↦ X → X) := (inferInstance : C /-- The group isomorphism between `Function.End X` and `CategoryTheory.End X`. -/ @[simps apply symm_apply] def endEquiv (X : Type u) : Function.End X ≃* End X where - toFun f := TypeCat.ofHom f + toFun f := ↾ f invFun f := (ConcreteCategory.hom f : _ → _) left_inv := by intro; rfl right_inv := by intro; rfl @@ -77,10 +77,10 @@ def ofMulActionLimitCone {ι : Type v} (G : Type max v u) [Monoid G] (F : ι → LimitCone (Discrete.functor fun i : ι => Action.ofMulAction G (F i)) where cone := { pt := Action.ofMulAction G (∀ i : ι, F i) - π := Discrete.natTrans (fun i => ⟨TypeCat.ofHom (fun x => x i.as), fun _ => rfl⟩) } + π := Discrete.natTrans (fun i => ⟨↾ (fun x => x i.as), fun _ => rfl⟩) } isLimit := { lift := fun s => - { hom := TypeCat.ofHom fun x i => (s.π.app ⟨i⟩).hom x + { hom := ↾ fun x i => (s.π.app ⟨i⟩).hom x comm := fun g => by ext x funext j diff --git a/Mathlib/CategoryTheory/Adjunction/Limits.lean b/Mathlib/CategoryTheory/Adjunction/Limits.lean index 7bca0a313c352d..ea1e4d69326da8 100644 --- a/Mathlib/CategoryTheory/Adjunction/Limits.lean +++ b/Mathlib/CategoryTheory/Adjunction/Limits.lean @@ -314,8 +314,8 @@ the functor associating to each `Y` the cocones over `K` with cone point `G.obj def coconesIso {J : Type u} [Category.{v} J] {K : J ⥤ C} : (cocones J D).obj (op (K ⋙ F)) ≅ G ⋙ (cocones J C).obj (op K) := NatIso.ofComponents fun Y => - { hom := TypeCat.ofHom (coconesIsoComponentHom adj Y) - inv := TypeCat.ofHom (coconesIsoComponentInv adj Y) } + { hom := ↾ (coconesIsoComponentHom adj Y) + inv := ↾ (coconesIsoComponentInv adj Y) } -- Note: this is natural in K, but we do not yet have the tools to formulate that. /-- When `F ⊣ G`, @@ -326,8 +326,8 @@ the functor associating to each `X` the cones over `K ⋙ G` with cone point `X` def conesIso {J : Type u} [Category.{v} J] {K : J ⥤ D} : F.op ⋙ (cones J D).obj K ≅ (cones J C).obj (K ⋙ G) := NatIso.ofComponents fun X => - { hom := TypeCat.ofHom (conesIsoComponentHom adj X) - inv := TypeCat.ofHom (conesIsoComponentInv adj X) } + { hom := ↾ (conesIsoComponentHom adj X) + inv := ↾ (conesIsoComponentInv adj X) } end Adjunction diff --git a/Mathlib/CategoryTheory/Category/Cat.lean b/Mathlib/CategoryTheory/Category/Cat.lean index 9fc8c9cbfa1bf3..fab181a6c0787a 100644 --- a/Mathlib/CategoryTheory/Category/Cat.lean +++ b/Mathlib/CategoryTheory/Category/Cat.lean @@ -362,7 +362,7 @@ theorem comp_eq_comp {X Y Z : Cat} (F : X ⟶ Y) (G : Y ⟶ Z) : called `forget`, because it is not a faithful functor. -/ def objects : Cat.{v, u} ⥤ Type u where obj C := C - map F := TypeCat.ofHom F.toFunctor.obj + map F := ↾ F.toFunctor.obj /-- See through the defeq `objects.obj X = X`. -/ instance (X : Cat.{v, u}) : Category (objects.obj X) := inferInstanceAs <| Category X @@ -426,7 +426,7 @@ instance : Functor.Faithful typeToCat.{u} where exact congrArg Discrete.as (Functor.congr_obj congr(($h).toFunctor) ⟨x⟩) instance : Functor.Full typeToCat.{u} where - map_surjective F := ⟨TypeCat.ofHom (Discrete.as ∘ F.toFunctor.obj ∘ Discrete.mk), by + map_surjective F := ⟨↾ (Discrete.as ∘ F.toFunctor.obj ∘ Discrete.mk), by ext refine Functor.ext (by cat_disch) ?_ intro x y f diff --git a/Mathlib/CategoryTheory/Category/Cat/Adjunction.lean b/Mathlib/CategoryTheory/Category/Cat/Adjunction.lean index f91be7ae6312d8..d46f52d21343be 100644 --- a/Mathlib/CategoryTheory/Category/Cat/Adjunction.lean +++ b/Mathlib/CategoryTheory/Category/Cat/Adjunction.lean @@ -34,7 +34,7 @@ set_option backward.isDefEq.respectTransparency false in set_option backward.privateInPublic true in set_option backward.privateInPublic.warn false in private def typeToCatObjectsAdjHomEquiv : (typeToCat.obj X ⟶ C) ≃ (X ⟶ Cat.objects.obj C) where - toFun F := TypeCat.ofHom fun x ↦ F.toFunctor.obj ⟨x⟩ + toFun F := ↾ fun x ↦ F.toFunctor.obj ⟨x⟩ invFun f := (Discrete.functor f).toCatHom left_inv F := Hom.ext <| Functor.ext (fun _ ↦ rfl) (fun ⟨_⟩ ⟨_⟩ f => by obtain rfl := Discrete.eq_of_hom f @@ -52,7 +52,7 @@ set_option backward.privateInPublic.warn false in def typeToCatObjectsAdj : typeToCat ⊣ Cat.objects := Adjunction.mk' { homEquiv := typeToCatObjectsAdjHomEquiv - unit := { app := fun _ ↦ TypeCat.ofHom Discrete.mk } + unit := { app := fun _ ↦ ↾ Discrete.mk } counit := { app C := (typeToCatObjectsAdjCounitApp C).toCatHom naturality := fun _ _ _ ↦ Hom.ext <| Functor.hext (fun _ ↦ rfl) @@ -63,7 +63,7 @@ def typeToCatObjectsAdj : typeToCat ⊣ Cat.objects := /-- The connected components functor -/ def connectedComponents : Cat.{v, u} ⥤ Type u where obj C := ConnectedComponents C - map F := TypeCat.ofHom (Functor.mapConnectedComponents F.toFunctor) + map F := ↾ (Functor.mapConnectedComponents F.toFunctor) map_id _ := by ext x; simpa using (Quotient.exists_rep x).elim (fun _ h ↦ by subst h; rfl) map_comp _ _ := by ext x; simpa using (Quotient.exists_rep x).elim (fun _ h => by subst h; rfl) @@ -78,7 +78,7 @@ def connectedComponentsTypeToCatAdj : connectedComponents.{u} ⊣ typeToCat.{u} { app := fun C ↦ Functor.toCatHom <| ConnectedComponents.functorToDiscrete _ (𝟙 (connectedComponents.obj C)) } counit := { - app := fun X => TypeCat.ofHom (ConnectedComponents.liftFunctor _ + app := fun X => ↾ (ConnectedComponents.liftFunctor _ (𝟙 typeToCat.obj X).toFunctor) naturality := fun _ _ _ => by ext xcc diff --git a/Mathlib/CategoryTheory/Category/Cat/Limit.lean b/Mathlib/CategoryTheory/Category/Cat/Limit.lean index 7bc86a6d1187cb..b453446b871103 100644 --- a/Mathlib/CategoryTheory/Category/Cat/Limit.lean +++ b/Mathlib/CategoryTheory/Category/Cat/Limit.lean @@ -49,7 +49,7 @@ the diagram whose limit gives the morphism space between two objects of the limi def homDiagram {F : J ⥤ Cat.{v, v}} (X Y : limit (F ⋙ Cat.objects.{v, v})) : J ⥤ Type v where obj j := limit.π (F ⋙ Cat.objects) j X ⟶ limit.π (F ⋙ Cat.objects) j Y - map f := TypeCat.ofHom fun g ↦ by + map f := ↾ fun g ↦ by refine eqToHom ?_ ≫ (F.map f).toFunctor.map g ≫ eqToHom ?_ · exact (congr_hom (limit.w (F ⋙ Cat.objects) f) X).symm · exact congr_hom (limit.w (F ⋙ Cat.objects) f) Y @@ -108,7 +108,7 @@ def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F := limit.lift (F ⋙ Cat.objects) { pt := s.pt π := - { app := fun j => TypeCat.ofHom (s.π.app j).toFunctor.obj + { app := fun j => ↾ (s.π.app j).toFunctor.obj naturality := fun _ _ f => objects.congr_map (s.π.naturality f) } } map f := by fapply Types.Limit.mk.{v, v} diff --git a/Mathlib/CategoryTheory/Category/Pointed.lean b/Mathlib/CategoryTheory/Category/Pointed.lean index 6b33c825d153fa..a17f57a43d3500 100644 --- a/Mathlib/CategoryTheory/Category/Pointed.lean +++ b/Mathlib/CategoryTheory/Category/Pointed.lean @@ -116,7 +116,7 @@ def typeToPointed : Type u ⥤ Pointed.{u} where def typeToPointedForgetAdjunction : typeToPointed ⊣ forget Pointed := Adjunction.mkOfHomEquiv { homEquiv := fun X Y => - { toFun := fun f => TypeCat.ofHom (f.toFun ∘ Option.some) + { toFun := fun f => ↾ (f.toFun ∘ Option.some) invFun := fun f => ⟨fun o => o.elim Y.point f, rfl⟩ left_inv := fun f => by apply Pointed.Hom.ext diff --git a/Mathlib/CategoryTheory/Category/RelCat.lean b/Mathlib/CategoryTheory/Category/RelCat.lean index 2c913877f554a1..d0fbdd5db71309 100644 --- a/Mathlib/CategoryTheory/Category/RelCat.lean +++ b/Mathlib/CategoryTheory/Category/RelCat.lean @@ -96,11 +96,11 @@ theorem rel_iso_iff {X Y : RelCat} (r : X ⟶ Y) : simp only [RelCat.Hom.rel_comp_apply₂, RelCat.Hom.rel_id_apply₂, eq_iff_iff] at h1 h2 obtain ⟨f, hf⟩ := Classical.axiomOfChoice (fun a => (h1 a a).mpr rfl) obtain ⟨g, hg⟩ := Classical.axiomOfChoice (fun a => (h2 a a).mpr rfl) - suffices hif : IsIso (C := Type u) (TypeCat.ofHom f) by - use asIso (TypeCat.ofHom f) + suffices hif : IsIso (C := Type u) (↾ f) by + use asIso (↾ f) ext ⟨x, y⟩ exact ⟨by aesop, fun hxy ↦ (h2 (f x) y).1 ⟨x, (hf x).2, hxy⟩⟩ - use TypeCat.ofHom g + use ↾ g constructor · ext x apply (h1 _ _).mp diff --git a/Mathlib/CategoryTheory/CodiscreteCategory.lean b/Mathlib/CategoryTheory/CodiscreteCategory.lean index 98c642d72e5e70..6d9d59b8b9d93c 100644 --- a/Mathlib/CategoryTheory/CodiscreteCategory.lean +++ b/Mathlib/CategoryTheory/CodiscreteCategory.lean @@ -138,7 +138,7 @@ lemma adj_unit_app (X : Cat.{0, u}) : adj.unit.app X = (unitApp X).toCatHom := rfl lemma adj_counit_app (A : Type u) : - adj.counit.app A = TypeCat.ofHom (counitApp A) := rfl + adj.counit.app A = ↾ (counitApp A) := rfl /-- Left triangle equality of the adjunction `Cat.objects ⊣ Codiscrete.functorToCat`, as a universe polymorphic statement. -/ diff --git a/Mathlib/CategoryTheory/CofilteredSystem.lean b/Mathlib/CategoryTheory/CofilteredSystem.lean index cf7b74697a00af..3cf7e8ad7b0c2d 100644 --- a/Mathlib/CategoryTheory/CofilteredSystem.lean +++ b/Mathlib/CategoryTheory/CofilteredSystem.lean @@ -165,7 +165,7 @@ theorem isMittagLeffler_of_surjective (h : ∀ ⦃i j : J⦄ (f : i ⟶ j), Func @[simps] def toPreimages : J ⥤ Type v where obj j := ⋂ f : j ⟶ i, F.map f ⁻¹' s - map g := TypeCat.ofHom (MapsTo.restrict (F.map g) _ _ fun x h => by + map g := ↾ (MapsTo.restrict (F.map g) _ _ fun x h => by rw [mem_iInter] at h ⊢ intro f rw [← mem_preimage, preimage_preimage, mem_preimage] @@ -244,7 +244,7 @@ theorem isMittagLeffler_of_exists_finite_range @[simps obj map] def toEventualRanges : J ⥤ Type v where obj j := F.eventualRange j - map f := TypeCat.ofHom ((F.eventualRange_mapsTo f).restrict _ _ _) + map f := ↾ ((F.eventualRange_mapsTo f).restrict _ _ _) instance toEventualRanges_finite [∀ j, Finite (F.obj j)] : ∀ j, Finite (F.toEventualRanges.obj j) := fun _ => Subtype.finite diff --git a/Mathlib/CategoryTheory/Comma/Presheaf/Basic.lean b/Mathlib/CategoryTheory/Comma/Presheaf/Basic.lean index 116e1ece04e5c3..47525b796608ff 100644 --- a/Mathlib/CategoryTheory/Comma/Presheaf/Basic.lean +++ b/Mathlib/CategoryTheory/Comma/Presheaf/Basic.lean @@ -192,8 +192,8 @@ lemma yonedaArrow_val {Y : C} {η : yoneda.obj Y ⟶ A} {X : C} {s : yoneda.obj arrows. -/ def costructuredArrowIso (s t : CostructuredArrow yoneda A) : (OverArrows s.hom t.hom) ≅ (t ⟶ s) where - hom := TypeCat.ofHom (fun p ↦ CostructuredArrow.homMk p.val (by simp)) - inv := TypeCat.ofHom (fun f ↦ yonedaArrow f.left f.w) + hom := ↾ (fun p ↦ CostructuredArrow.homMk p.val (by simp)) + inv := ↾ (fun f ↦ yonedaArrow f.left f.w) end OverArrows @@ -204,13 +204,13 @@ smaller universe. -/ def restrictedYonedaObj {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v where obj s := OverArrows η s.unop.hom - map f := TypeCat.ofHom (fun u ↦ u.map₂ f.unop.left f.unop.w) + map f := ↾ (fun u ↦ u.map₂ f.unop.left f.unop.w) /-- Functoriality of `restrictedYonedaObj η` in `η`. -/ @[simps] def restrictedYonedaObjMap₁ {F G : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {μ : G ⟶ A} (ε : F ⟶ G) (hε : ε ≫ μ = η) : restrictedYonedaObj η ⟶ restrictedYonedaObj μ where - app _ := TypeCat.ofHom (fun u ↦ u.map₁ ε hε) + app _ := ↾ (fun u ↦ u.map₁ ε hε) /-- This is basically just `yoneda : Over A ⥤ (Over A)ᵒᵖ ⥤ Type (max u v)` restricted in the second @@ -386,13 +386,13 @@ end YonedaCollection def yonedaCollectionPresheaf (A : Cᵒᵖ ⥤ Type v) (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) : Cᵒᵖ ⥤ Type v where obj X := YonedaCollection F X.unop - map f := TypeCat.ofHom (YonedaCollection.map₂ F f.unop) + map f := ↾ (YonedaCollection.map₂ F f.unop) /-- Functoriality of `yonedaCollectionPresheaf A F` in `F`. -/ @[simps] def yonedaCollectionPresheafMap₁ {F G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v} (η : F ⟶ G) : yonedaCollectionPresheaf A F ⟶ yonedaCollectionPresheaf A G where - app _ := TypeCat.ofHom (YonedaCollection.map₁ η) + app _ := ↾ (YonedaCollection.map₁ η) naturality := by intros ext @@ -409,7 +409,7 @@ def yonedaCollectionFunctor (A : Cᵒᵖ ⥤ Type v) : @[simps] def yonedaCollectionPresheafToA (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) : yonedaCollectionPresheaf A F ⟶ A where - app _ := TypeCat.ofHom (YonedaCollection.yonedaEquivFst) + app _ := ↾ (YonedaCollection.yonedaEquivFst) /-- This is the reverse direction of the equivalence we're constructing. -/ @[simps! obj map] @@ -469,8 +469,8 @@ lemma unitBackward_unitForward {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) (X : C) : @[simps] def unitAuxAuxAux {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) (X : C) : YonedaCollection (restrictedYonedaObj η) X ≅ F.obj (op X) where - hom := TypeCat.ofHom (unitForward η X) - inv := TypeCat.ofHom (unitBackward η X) + hom := ↾ (unitForward η X) + inv := ↾ (unitBackward η X) hom_inv_id := ConcreteCategory.ext (TypeCat.Fun.ext (unitBackward_unitForward η X)) inv_hom_id := ConcreteCategory.ext (TypeCat.Fun.ext (unitForward_unitBackward η X)) @@ -562,8 +562,8 @@ lemma counitBackward_counitForward (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ T def counitAuxAux (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) (s : CostructuredArrow yoneda A) : F.obj (op s) ≅ OverArrows (yonedaCollectionPresheafToA F) s.hom where - hom := TypeCat.ofHom (counitForward F s) - inv := TypeCat.ofHom (counitBackward F s) + hom := ↾ (counitForward F s) + inv := ↾ (counitBackward F s) hom_inv_id := ConcreteCategory.ext (TypeCat.Fun.ext (counitBackward_counitForward F s)) inv_hom_id := ConcreteCategory.ext (TypeCat.Fun.ext (counitForward_counitBackward F s)) diff --git a/Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean b/Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean index 9f71c1fbe3e6e6..e1dcd1d2746fc7 100644 --- a/Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean +++ b/Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean @@ -39,10 +39,10 @@ namespace ConcreteCategory section instance [(forget C).PreservesMonomorphisms] {X Y : C} (f : X ⟶ Y) [Mono f] : - Mono (TypeCat.ofHom f) := Functor.map_mono (forget C) f + Mono (↾ f) := Functor.map_mono (forget C) f instance [(forget C).PreservesEpimorphisms] {X Y : C} (f : X ⟶ Y) [Epi f] : - Epi (TypeCat.ofHom f) := Functor.map_epi (forget C) f + Epi (↾ f) := Functor.map_epi (forget C) f /-- In any concrete category, injective morphisms are monomorphisms. -/ theorem mono_of_injective {X Y : C} (f : X ⟶ Y) (i : Function.Injective f) : diff --git a/Mathlib/CategoryTheory/ConcreteCategory/Forget.lean b/Mathlib/CategoryTheory/ConcreteCategory/Forget.lean index 4a8b23a5ddbf12..276b8a31ddf0c9 100644 --- a/Mathlib/CategoryTheory/ConcreteCategory/Forget.lean +++ b/Mathlib/CategoryTheory/ConcreteCategory/Forget.lean @@ -48,7 +48,7 @@ variable (C : Type*) [Category* C] {FC : outParam <| C → C → Type*} {CC : ou /-- The forgetful functor from a concrete category to the category of types. -/ abbrev forget : C ⥤ Type w where obj X := ToType X - map f := TypeCat.ofHom f + map f := ↾ f instance : (forget C).Faithful where map_injective h := ConcreteCategory.hom_ext _ _ fun x ↦ ConcreteCategory.congr_hom h x @@ -57,7 +57,7 @@ variable {C} @[simp] lemma ConcreteCategory.forget_map_eq_ofHom {X Y : C} (f : X ⟶ Y) : - (forget C).map f = TypeCat.ofHom f := + (forget C).map f = ↾ f := rfl @[deprecated (since := "2026-04-11")] alias ConcreteCategory.forget_map_eq_coe := @@ -150,7 +150,7 @@ lemma ConcreteCategory.forget₂_comp_apply [HasForget₂ C D] {X Y Z : C} rw [Functor.map_comp, CategoryTheory.comp_apply] instance hom_isIso {X Y : C} (f : X ⟶ Y) [IsIso f] : - IsIso (C := Type _) (TypeCat.ofHom (ConcreteCategory.hom f)) := + IsIso (C := Type _) (↾ (ConcreteCategory.hom f)) := ((forget C).mapIso (asIso f)).isIso_hom end CategoryTheory diff --git a/Mathlib/CategoryTheory/Elements.lean b/Mathlib/CategoryTheory/Elements.lean index f9ff56477e2fee..4adaa2b85777c5 100644 --- a/Mathlib/CategoryTheory/Elements.lean +++ b/Mathlib/CategoryTheory/Elements.lean @@ -167,7 +167,7 @@ theorem map_π {F₁ F₂ : C ⥤ Type w} (α : F₁ ⟶ F₂) : map α ⋙ π F /-- The forward direction of the equivalence `F.Elements ≅ (*, F)`. -/ def toStructuredArrow : F.Elements ⥤ StructuredArrow PUnit F where - obj X := StructuredArrow.mk <| TypeCat.ofHom (fun _ => X.2) + obj X := StructuredArrow.mk <| ↾ (fun _ => X.2) map {X Y} f := StructuredArrow.homMk f.val (by ext; simp [f.2]) @[simp] @@ -175,7 +175,7 @@ theorem toStructuredArrow_obj (X) : (toStructuredArrow F).obj X = { left := ⟨⟨⟩⟩ right := X.1 - hom := TypeCat.ofHom (fun _ => X.2) } := + hom := ↾ (fun _ => X.2) } := rfl @[simp] diff --git a/Mathlib/CategoryTheory/Enriched/Basic.lean b/Mathlib/CategoryTheory/Enriched/Basic.lean index e3429afc7e18bb..ab7d211066a8dd 100644 --- a/Mathlib/CategoryTheory/Enriched/Basic.lean +++ b/Mathlib/CategoryTheory/Enriched/Basic.lean @@ -171,8 +171,8 @@ attribute [local simp] types_tensorObj_def in def enrichedCategoryTypeOfCategory (C : Type u₁) [𝒞 : Category.{v} C] : EnrichedCategory (Type v) C where Hom X Y := 𝒞.Hom X Y - id X := TypeCat.ofHom (fun _ ↦ 𝟙 _) - comp _ _ _ := TypeCat.ofHom (fun p ↦ p.1 ≫ p.2) + id X := ↾ (fun _ ↦ 𝟙 _) + comp _ _ _ := ↾ (fun p ↦ p.1 ≫ p.2) /-- We verify that an enriched category in `Type u` is just the same thing as an honest category. -/ @@ -482,7 +482,7 @@ the `V`-object of natural transformations from `F` to `G`. @[simps] def enrichedNatTransYoneda (F G : EnrichedFunctor V C D) : Vᵒᵖ ⥤ Type (max u₁ w) where obj A := GradedNatTrans ((Center.ofBraided V).obj (unop A)) F G - map f := TypeCat.ofHom fun σ ↦ + map f := ↾ fun σ ↦ { app X := f.unop ≫ σ.app X naturality X Y := by have p := σ.naturality X Y @@ -513,7 +513,7 @@ def enrichedFunctorTypeEquivFunctor {C : Type u₁} [𝒞 : EnrichedCategory (Ty map_comp := fun f g => ConcreteCategory.congr_hom (F.map_comp _ _ _) ⟨f, g⟩ } invFun F := { obj := fun X => F.obj X - map := fun _ _ => TypeCat.ofHom (fun f => F.map f) + map := fun _ _ => ↾ (fun f => F.map f) map_id := fun X => by ext ⟨⟩; exact F.map_id X map_comp := fun X Y Z => by ext ⟨f, g⟩; exact F.map_comp f g } @@ -528,11 +528,11 @@ def enrichedNatTransYonedaTypeIsoYonedaNatTrans {C : Type v} [EnrichedCategory ( enrichedFunctorTypeEquivFunctor G) := NatIso.ofComponents (fun α => - { hom := TypeCat.ofHom fun σ ↦ TypeCat.ofHom fun x => + { hom := ↾ fun σ ↦ ↾ fun x => { app X := σ.app X x naturality X Y f := ConcreteCategory.congr_hom (σ.naturality X Y) ⟨x, f⟩ } - inv := TypeCat.ofHom fun σ ↦ - { app X := TypeCat.ofHom (fun x => (σ.hom x).app X) + inv := ↾ fun σ ↦ + { app X := ↾ (fun x => (σ.hom x).app X) naturality X Y := by ext ⟨x, f⟩; exact (σ.hom x).naturality f } }) (by cat_disch) diff --git a/Mathlib/CategoryTheory/Extensive.lean b/Mathlib/CategoryTheory/Extensive.lean index fc7a5679a80c47..46151270ce296e 100644 --- a/Mathlib/CategoryTheory/Extensive.lean +++ b/Mathlib/CategoryTheory/Extensive.lean @@ -228,7 +228,7 @@ instance types.finitaryExtensive : FinitaryExtensive (Type u) := by (ConcreteCategory.congr_hom hαY val :).symm delta ExistsUnique at this choose l hl hl' using this - refine ⟨TypeCat.ofHom (l), ?_, Types.isTerminalPUnit.hom_ext _ _, fun {l'} h₁ _ => ?_⟩ + refine ⟨↾ (l), ?_, Types.isTerminalPUnit.hom_ext _ _, fun {l'} h₁ _ => ?_⟩ · ext x exact (hl x).symm · ext x @@ -244,7 +244,7 @@ instance types.finitaryExtensive : FinitaryExtensive (Type u) := by · simp delta ExistsUnique at this choose l hl hl' using this - refine ⟨TypeCat.ofHom l, ?_, Types.isTerminalPUnit.hom_ext _ _, fun {l'} h₁ _ => ?_⟩ + refine ⟨↾ l, ?_, Types.isTerminalPUnit.hom_ext _ _, fun {l'} h₁ _ => ?_⟩ · ext x exact (hl x).symm · ext x @@ -262,7 +262,7 @@ instance types.finitaryExtensive : FinitaryExtensive (Type u) := by ⟨fun p => ⟨p.1.1, p.2.trans (congr_arg Sum.inr <| Subsingleton.elim _ _)⟩, fun x => ⟨⟨_, _⟩, x.2⟩, fun _ => by ext; rfl, fun _ => by ext; rfl⟩ fapply BinaryCofan.isColimitMk - · exact fun s => TypeCat.ofHom fun x => dite _ (fun h => s.inl <| eX.symm ⟨x, h⟩) + · exact fun s => ↾ fun x => dite _ (fun h => s.inl <| eX.symm ⟨x, h⟩) fun h => s.inr <| eY.symm ⟨x, (this x).resolve_left h⟩ · intro s ext ⟨⟨x, ⟨⟩⟩, _⟩ diff --git a/Mathlib/CategoryTheory/FintypeCat.lean b/Mathlib/CategoryTheory/FintypeCat.lean index 58c7fc8d6c7623..44a09e82f26916 100644 --- a/Mathlib/CategoryTheory/FintypeCat.lean +++ b/Mathlib/CategoryTheory/FintypeCat.lean @@ -91,18 +91,18 @@ lemma hom_ext {X Y : FintypeCat} (f g : X ⟶ Y) (h : ∀ x, f x = g x) : f = g /-- Constructor for morphisms in `FintypeCat`. -/ def homMk {X Y : FintypeCat} (f : X → Y) : X ⟶ Y where - hom := TypeCat.ofHom f + hom := ↾ f @[simp] lemma homMk_apply {X Y : FintypeCat} (f : X → Y) (x : X) : homMk f x = f x := rfl @[simp] -lemma id_hom (X : FintypeCat) : 𝟙 X.obj = TypeCat.ofHom id := rfl +lemma id_hom (X : FintypeCat) : 𝟙 X.obj = ↾ id := rfl @[simp, reassoc] lemma comp_hom {X Y Z : FintypeCat} (f : X ⟶ Y) (g : Y ⟶ Z) : - f.hom ≫ g.hom = TypeCat.ofHom (g.hom ∘ f.hom) := rfl + f.hom ≫ g.hom = ↾ (g.hom ∘ f.hom) := rfl @[simp] lemma homMk_eq_id_iff {X : FintypeCat} (f : X → X) : diff --git a/Mathlib/CategoryTheory/Functor/FunctorHom.lean b/Mathlib/CategoryTheory/Functor/FunctorHom.lean index 08eef6b276583d..15c27f7734c9fe 100644 --- a/Mathlib/CategoryTheory/Functor/FunctorHom.lean +++ b/Mathlib/CategoryTheory/Functor/FunctorHom.lean @@ -47,10 +47,10 @@ structure HomObj (A : C ⥤ Type w) where bijection with `F ⊗ A ⟶ G`. -/ @[simps] def homObjEquiv (F G A : C ⥤ Type w) : (HomObj F G A) ≃ (F ⊗ A ⟶ G) where - toFun a := ⟨fun X ↦ TypeCat.ofHom fun ⟨x, y⟩ ↦ a.app X y x, fun X Y f ↦ by + toFun a := ⟨fun X ↦ ↾ fun ⟨x, y⟩ ↦ a.app X y x, fun X Y f ↦ by ext ⟨x, y⟩ simpa using ConcreteCategory.congr_hom (a.naturality f y) x⟩ - invFun a := ⟨fun X y ↦ TypeCat.ofHom (fun x ↦ a.app X (x, y)), fun φ y ↦ by + invFun a := ⟨fun X y ↦ ↾ (fun x ↦ a.app X (x, y)), fun φ y ↦ by ext x simpa using (a.naturality_apply φ) (x, y)⟩ left_inv _ := by aesop @@ -92,7 +92,7 @@ end HomObj @[simps obj map] def homObjFunctor : (C ⥤ Type w)ᵒᵖ ⥤ Type (max w v' u) where obj A := HomObj F G A.unop - map {A A'} f := TypeCat.ofHom fun x ↦ + map {A A'} f := ↾ fun x ↦ { app := fun X a ↦ x.app X (f.unop.app _ a) naturality := fun {X Y} φ a ↦ by rw [← HomObj.naturality] @@ -122,7 +122,7 @@ def functorHomEquiv (A : C ⥤ Type (max u v v')) : (A ⟶ F.functorHom G) ≃ H have := HomObj.congr_app (ConcreteCategory.congr_hom (φ.naturality f) a) Y (𝟙 _) simp_all [-NatTrans.naturality, functorHom, homObjFunctor] } invFun x := - { app X := TypeCat.ofHom (fun a ↦ { app := fun Y f => x.app Y (A.map f a) }) + { app X := ↾ (fun a ↦ { app := fun Y f => x.app Y (A.map f a) }) naturality X Y f := by ext simp [functorHom, homObjFunctor] } @@ -145,7 +145,7 @@ def natTransEquiv : (𝟙_ (C ⥤ Type (max v' v u)) ⟶ F.functorHom G) ≃ (F have := HomObj.congr_app (ConcreteCategory.congr_hom (f.naturality φ) PUnit.unit) Y (𝟙 Y) dsimp [functorHom, homObjFunctor] at this aesop ⟩ - invFun f := { app _ := TypeCat.ofHom (fun _ ↦ HomObj.ofNatTrans f) } + invFun f := { app _ := ↾ (fun _ ↦ HomObj.ofNatTrans f) } left_inv f := by ext X a Y φ have := HomObj.congr_app (ConcreteCategory.congr_hom (f.naturality φ) PUnit.unit) Y (𝟙 Y) @@ -203,6 +203,6 @@ attribute [local simp] functorHom types_tensorObj_def in instance : EnrichedCategory (C ⥤ Type (max v' v u)) (C ⥤ D) where Hom := functorHom id F := natTransEquiv.symm (𝟙 F) - comp F G H := { app _ := TypeCat.ofHom (fun f ↦ f.1.comp f.2) } + comp F G H := { app _ := ↾ (fun f ↦ f.1.comp f.2) } end CategoryTheory.Enriched.Functor diff --git a/Mathlib/CategoryTheory/Functor/Hom.lean b/Mathlib/CategoryTheory/Functor/Hom.lean index e04dd3d8822f4f..f49ce055bd25b8 100644 --- a/Mathlib/CategoryTheory/Functor/Hom.lean +++ b/Mathlib/CategoryTheory/Functor/Hom.lean @@ -30,6 +30,6 @@ covariant in `Y`. -/ @[simps] def hom : Cᵒᵖ × C ⥤ Type v where obj p := unop p.1 ⟶ p.2 - map f := TypeCat.ofHom fun h => f.1.unop ≫ h ≫ f.2 + map f := ↾ fun h => f.1.unop ≫ h ≫ f.2 end CategoryTheory.Functor diff --git a/Mathlib/CategoryTheory/Functor/KanExtension/Dense.lean b/Mathlib/CategoryTheory/Functor/KanExtension/Dense.lean index 6394a06f420eb0..5f726b2c09d432 100644 --- a/Mathlib/CategoryTheory/Functor/KanExtension/Dense.lean +++ b/Mathlib/CategoryTheory/Functor/KanExtension/Dense.lean @@ -125,7 +125,7 @@ lemma IsDense.of_fullyFaithful_restrictedULiftYoneda [F.Full] isDenseAt Y := by let φ (s : Cocone (CostructuredArrow.proj F Y ⋙ F)) : (restrictedULiftYoneda.{w} F).obj Y ⟶ (restrictedULiftYoneda F).obj s.pt := - { app := fun ⟨X⟩ ↦ TypeCat.ofHom fun ⟨x⟩ ↦ ULift.up (s.ι.app (.mk x)) + { app := fun ⟨X⟩ ↦ ↾ fun ⟨x⟩ ↦ ULift.up (s.ι.app (.mk x)) naturality := by rintro ⟨X₁⟩ ⟨X₂⟩ ⟨f⟩ ext ⟨x⟩ diff --git a/Mathlib/CategoryTheory/Galois/Prorepresentability.lean b/Mathlib/CategoryTheory/Galois/Prorepresentability.lean index b3a324c10c0b27..41911eb29d3b05 100644 --- a/Mathlib/CategoryTheory/Galois/Prorepresentability.lean +++ b/Mathlib/CategoryTheory/Galois/Prorepresentability.lean @@ -149,7 +149,7 @@ This is a colimit cocone (see `PreGaloisCategory.isColimit`) -/ def cocone : Cocone ((incl F).op ⋙ coyoneda) where pt := F ⋙ FintypeCat.incl ι := { - app := fun ⟨A, a, _⟩ ↦ { app X := TypeCat.ofHom (fun (f : (A : C) ⟶ X) ↦ F.map f a) } + app := fun ⟨A, a, _⟩ ↦ { app X := ↾ (fun (f : (A : C) ⟶ X) ↦ F.map f a) } naturality := fun ⟨A, a, _⟩ ⟨B, b, _⟩ ⟨f, (hf : F.map f b = a)⟩ ↦ by ext Y (g : (A : C) ⟶ Y) suffices h : F.map g (F.map f b) = F.map g a by simpa @@ -158,7 +158,7 @@ def cocone : Cocone ((incl F).op ⋙ coyoneda) where @[simp] lemma cocone_app (A : PointedGaloisObject F) (B : C) : - ((cocone F).ι.app ⟨A⟩).app B = TypeCat.ofHom (fun (f : (A : C) ⟶ B) ↦ F.map f A.pt) := + ((cocone F).ι.app ⟨A⟩).app B = ↾ (fun (f : (A : C) ⟶ B) ↦ F.map f A.pt) := rfl variable [FiberFunctor F] diff --git a/Mathlib/CategoryTheory/Galois/Topology.lean b/Mathlib/CategoryTheory/Galois/Topology.lean index 0c660bdba42eb4..b1e1467963e337 100644 --- a/Mathlib/CategoryTheory/Galois/Topology.lean +++ b/Mathlib/CategoryTheory/Galois/Topology.lean @@ -65,7 +65,7 @@ scoped instance (X : C) : TopologicalSpace (Aut (F.obj X)) := ⊥ /-- We give `F.obj X ⟶ F.obj Y` the product topology. -/ @[local simp] scoped instance {X Y : C} : TopologicalSpace (F.obj X ⟶ F.obj Y) := - .coinduced (fun f ↦ ObjectProperty.homMk (TypeCat.ofHom f)) inferInstance + .coinduced (fun f ↦ ObjectProperty.homMk (↾ f)) inferInstance scoped instance {X Y : C} : DiscreteTopology (F.obj X ⟶ F.obj Y) := ⟨by simp [DiscreteTopology.eq_bot]⟩ diff --git a/Mathlib/CategoryTheory/Generator/Type.lean b/Mathlib/CategoryTheory/Generator/Type.lean index 0e16d73cd6c417..d603e527d31c25 100644 --- a/Mathlib/CategoryTheory/Generator/Type.lean +++ b/Mathlib/CategoryTheory/Generator/Type.lean @@ -23,7 +23,7 @@ namespace CategoryTheory lemma Types.isSeparator_punit : IsSeparator (PUnit.{u + 1}) := by intro X Y f g h ext x - exact ConcreteCategory.congr_hom (h PUnit (by simp) (TypeCat.ofHom (fun _ ↦ x))) + exact ConcreteCategory.congr_hom (h PUnit (by simp) (↾ (fun _ ↦ x))) .unit end CategoryTheory diff --git a/Mathlib/CategoryTheory/Groupoid/Grpd/Basic.lean b/Mathlib/CategoryTheory/Groupoid/Grpd/Basic.lean index 0231779f74bd0b..0838f13f53493d 100644 --- a/Mathlib/CategoryTheory/Groupoid/Grpd/Basic.lean +++ b/Mathlib/CategoryTheory/Groupoid/Grpd/Basic.lean @@ -71,7 +71,7 @@ instance category : LargeCategory.{max v u} Grpd.{v, u} where called `forget`, because it is not a faithful functor. -/ def objects : Grpd.{v, u} ⥤ Type u where obj C := Bundled.α C - map F := TypeCat.ofHom F.obj + map F := ↾ F.obj /-- Forgetting functor to `Cat` -/ def forgetToCat : Grpd.{v, u} ⥤ Cat.{v, u} where diff --git a/Mathlib/CategoryTheory/IsomorphismClasses.lean b/Mathlib/CategoryTheory/IsomorphismClasses.lean index b379664c9f6bf5..5a7fee17878a05 100644 --- a/Mathlib/CategoryTheory/IsomorphismClasses.lean +++ b/Mathlib/CategoryTheory/IsomorphismClasses.lean @@ -44,7 +44,7 @@ end Category -/ def isomorphismClasses : Cat.{v, u} ⥤ Type u where obj C := Quotient (isIsomorphicSetoid C.α) - map {_ _} F := TypeCat.ofHom (Quot.map F.toFunctor.obj fun _ _ ⟨f⟩ => ⟨F.toFunctor.mapIso f⟩) + map {_ _} F := ↾ (Quot.map F.toFunctor.obj fun _ _ ⟨f⟩ => ⟨F.toFunctor.mapIso f⟩) map_id {C} := by -- Porting note: this used to be `tidy` ext x apply @Quot.recOn _ _ _ x diff --git a/Mathlib/CategoryTheory/Limits/Cones.lean b/Mathlib/CategoryTheory/Limits/Cones.lean index 4a32a6f23801fe..d7765f49701a19 100644 --- a/Mathlib/CategoryTheory/Limits/Cones.lean +++ b/Mathlib/CategoryTheory/Limits/Cones.lean @@ -168,8 +168,8 @@ namespace Cone /-- The isomorphism between a cone on `F` and an element of the functor `F.cones`. -/ @[simps!] def equiv (F : J ⥤ C) : dsimp% Cone F ≅ Σ X, F.cones.obj X where - hom := TypeCat.ofHom fun c ↦ ⟨op c.pt, c.π⟩ - inv := TypeCat.ofHom fun c ↦ + hom := ↾ fun c ↦ ⟨op c.pt, c.π⟩ + inv := ↾ fun c ↦ { pt := c.1.unop π := c.2 } hom_inv_id := by @@ -184,7 +184,7 @@ def equiv (F : J ⥤ C) : dsimp% Cone F ≅ Σ X, F.cones.obj X where /-- A map to the vertex of a cone naturally induces a cone by composition. -/ @[simps] def extensions (c : Cone F) : uliftYoneda.obj c.pt ⟶ F.cones where - app _ := TypeCat.ofHom (fun f ↦ (const J).map f.down ≫ c.π) + app _ := ↾ (fun f ↦ (const J).map f.down ≫ c.π) /-- A map to the vertex of a cone induces a cone by composition. -/ @[to_dual (attr := simps) @@ -208,8 +208,8 @@ namespace Cocone /-- The isomorphism between a cocone on `F` and an element of the functor `F.cocones`. -/ def equiv (F : J ⥤ C) : Cocone F ≅ Σ X, F.cocones.obj X where - hom := TypeCat.ofHom fun c ↦ ⟨c.pt, c.ι⟩ - inv := TypeCat.ofHom fun c ↦ + hom := ↾ fun c ↦ ⟨c.pt, c.ι⟩ + inv := ↾ fun c ↦ { pt := c.1 ι := c.2 } hom_inv_id := by @@ -224,7 +224,7 @@ def equiv (F : J ⥤ C) : Cocone F ≅ Σ X, F.cocones.obj X where /-- A map from the vertex of a cocone naturally induces a cocone by composition. -/ @[simps] def extensions (c : Cocone F) : coyoneda.obj (op c.pt) ⋙ uliftFunctor.{u₁} ⟶ F.cocones where - app _ := TypeCat.ofHom (fun f ↦ c.ι ≫ (const J).map f.down) + app _ := ↾ (fun f ↦ c.ι ≫ (const J).map f.down) end Cocone diff --git a/Mathlib/CategoryTheory/Limits/FunctorCategory/Shapes/Images.lean b/Mathlib/CategoryTheory/Limits/FunctorCategory/Shapes/Images.lean index c413ded61b33e5..1b7040ab5574ca 100644 --- a/Mathlib/CategoryTheory/Limits/FunctorCategory/Shapes/Images.lean +++ b/Mathlib/CategoryTheory/Limits/FunctorCategory/Shapes/Images.lean @@ -37,7 +37,7 @@ property of images -/ noncomputable def monoFactorisationIsImage {F G : C ⥤ Type u} (f : F ⟶ G) : IsImage <| monoFactorisation f where lift H := { - app X := TypeCat.ofHom fun ⟨x, hx⟩ ↦ H.e.app _ hx.choose + app X := ↾ fun ⟨x, hx⟩ ↦ H.e.app _ hx.choose naturality X Y g := by ext apply injective_of_mono (H.m.app Y) diff --git a/Mathlib/CategoryTheory/Limits/HasLimits.lean b/Mathlib/CategoryTheory/Limits/HasLimits.lean index f4899e912d77b8..59d55c262d51c5 100644 --- a/Mathlib/CategoryTheory/Limits/HasLimits.lean +++ b/Mathlib/CategoryTheory/Limits/HasLimits.lean @@ -272,7 +272,7 @@ def limit.homIso (F : J ⥤ C) [HasLimit F] (W : C) : @[simp] theorem limit.homIso_hom (F : J ⥤ C) [HasLimit F] {W : C} : - (limit.homIso F W).hom = TypeCat.ofHom (fun f ↦ (const J).map f.down ≫ (limit.cone F).π) := + (limit.homIso F W).hom = ↾ (fun f ↦ (const J).map f.down ≫ (limit.cone F).π) := (limit.isLimit F).homIso_hom /-- The isomorphism (in `Type`) between @@ -833,7 +833,7 @@ def colimit.homIso (F : J ⥤ C) [HasColimit F] (W : C) : @[simp] theorem colimit.homIso_hom (F : J ⥤ C) [HasColimit F] {W : C} : (colimit.homIso F W).hom = - TypeCat.ofHom (fun f ↦ (colimit.cocone F).ι ≫ (const J).map f.down) := + ↾ (fun f ↦ (colimit.cocone F).ι ≫ (const J).map f.down) := (colimit.isColimit F).homIso_hom /-- The isomorphism (in `Type`) between diff --git a/Mathlib/CategoryTheory/Limits/IsLimit.lean b/Mathlib/CategoryTheory/Limits/IsLimit.lean index ecba5f106ee43b..d5abf67750b572 100644 --- a/Mathlib/CategoryTheory/Limits/IsLimit.lean +++ b/Mathlib/CategoryTheory/Limits/IsLimit.lean @@ -388,7 +388,7 @@ def homIso (h : IsLimit t) (W : C) : @[simp] theorem homIso_hom (h : IsLimit t) {W : C} : - (IsLimit.homIso h W).hom = TypeCat.ofHom (fun f ↦ (t.extend f.down).π) := + (IsLimit.homIso h W).hom = ↾ (fun f ↦ (t.extend f.down).π) := rfl /-- The limit of `F` represents the functor taking `W` to @@ -402,9 +402,9 @@ def homIso' (h : IsLimit t) (W : C) : (ULift.{u₁} (W ⟶ t.pt : Type v₃)) ≅ { p : ∀ j, W ⟶ F.obj j // ∀ {j j'} (f : j ⟶ j'), p j ≫ F.map f = p j' } := h.homIso W ≪≫ - { hom := TypeCat.ofHom fun π => + { hom := ↾ fun π => ⟨fun j => π.app j, fun f => by convert ← (π.naturality f).symm; apply id_comp⟩ - inv := TypeCat.ofHom fun p => + inv := ↾ fun p => { app := fun j => p.1 j naturality := fun j j' f => by dsimp; rw [id_comp]; exact (p.2 f).symm } } @@ -435,10 +435,10 @@ there is a unique cone morphism from any other cone. -/ def isoUniqueConeMorphism {t : Cone F} : IsLimit t ≅ ∀ s, Unique (s ⟶ t) where - hom := TypeCat.ofHom fun h s ↦ + hom := ↾ fun h s ↦ { default := h.liftConeMorphism s uniq := fun _ => h.uniq_cone_morphism } - inv := TypeCat.ofHom fun h => + inv := ↾ fun h => { lift := fun s => (h s).default.hom uniq := fun s f w => congrArg ConeMorphism.hom ((h s).uniq ⟨f, w⟩) } @@ -886,7 +886,7 @@ def homIso (h : IsColimit t) (W : C) : @[simp] theorem homIso_hom (h : IsColimit t) {W : C} : - (IsColimit.homIso h W).hom = TypeCat.ofHom (fun f ↦ (t.extend f.down).ι) := + (IsColimit.homIso h W).hom = ↾ (fun f ↦ (t.extend f.down).ι) := rfl /-- The colimit of `F` represents the functor taking `W` to @@ -900,9 +900,9 @@ def homIso' (h : IsColimit t) (W : C) : (ULift.{u₁} (t.pt ⟶ W : Type v₃)) ≅ { p : ∀ j, F.obj j ⟶ W // ∀ {j j' : J} (f : j ⟶ j'), F.map f ≫ p j' = p j } := h.homIso W ≪≫ - { hom := TypeCat.ofHom fun ι => + { hom := ↾ fun ι => ⟨fun j => ι.app j, fun {j} {j'} f => by convert ← ι.naturality f; apply comp_id⟩ - inv := TypeCat.ofHom fun p => + inv := ↾ fun p => { app := fun j => p.1 j naturality := fun j j' f => by dsimp; rw [comp_id]; exact p.2 f } } @@ -934,10 +934,10 @@ there is a unique cocone morphism from any other cocone. -/ def isoUniqueCoconeMorphism {t : Cocone F} : IsColimit t ≅ ∀ s, Unique (t ⟶ s) where - hom := TypeCat.ofHom fun h s ↦ + hom := ↾ fun h s ↦ { default := h.descCoconeMorphism s uniq := fun _ => h.uniq_cocone_morphism } - inv := TypeCat.ofHom fun h ↦ + inv := ↾ fun h ↦ { desc := fun s => (h s).default.hom uniq := fun s f w => congrArg CoconeMorphism.hom ((h s).uniq ⟨f, w⟩) } diff --git a/Mathlib/CategoryTheory/Limits/MonoCoprod.lean b/Mathlib/CategoryTheory/Limits/MonoCoprod.lean index 7355662f0d50d6..28ac55dd634d80 100644 --- a/Mathlib/CategoryTheory/Limits/MonoCoprod.lean +++ b/Mathlib/CategoryTheory/Limits/MonoCoprod.lean @@ -93,10 +93,10 @@ theorem mk' (h : ∀ A B : C, ∃ (c : BinaryCofan A B) (_ : IsColimit c), Mono set_option backward.isDefEq.respectTransparency false in instance monoCoprodType : MonoCoprod (Type u) := MonoCoprod.mk' fun A B => by - refine ⟨BinaryCofan.mk (TypeCat.ofHom (Sum.inl : A → A ⊕ B)) - (TypeCat.ofHom Sum.inr), ?_, ?_⟩ + refine ⟨BinaryCofan.mk (↾ (Sum.inl : A → A ⊕ B)) + (↾ Sum.inr), ?_, ?_⟩ · exact BinaryCofan.IsColimit.mk _ - (fun f₁ f₂ => TypeCat.ofHom fun x => by + (fun f₁ f₂ => ↾ fun x => by rcases x with x | x exacts [f₁ x, f₂ x]) (fun f₁ f₂ => by rfl) diff --git a/Mathlib/CategoryTheory/Limits/Presheaf.lean b/Mathlib/CategoryTheory/Limits/Presheaf.lean index e663b68dbdc84c..afa90bb3a7feda 100644 --- a/Mathlib/CategoryTheory/Limits/Presheaf.lean +++ b/Mathlib/CategoryTheory/Limits/Presheaf.lean @@ -95,7 +95,7 @@ def restrictedULiftYonedaHomEquiv' (P : Cᵒᵖ ⥤ Type max w v₁ v₂) (E : (Functor.const (CostructuredArrow uliftYoneda.{max w v₂} P)).obj E) ≃ (P ⟶ (restrictedULiftYoneda.{max w v₁} A).obj E) where toFun f := - { app _ := TypeCat.ofHom fun x ↦ ULift.up + { app _ := ↾ fun x ↦ ULift.up (f.app (CostructuredArrow.mk (uliftYonedaEquiv.symm x))) naturality _ _ g := by ext x @@ -281,7 +281,7 @@ The result of [MM92], Chapter I, Section 5, Corollary 3. def colimitOfRepresentable (P : Cᵒᵖ ⥤ Type max w v₁) : IsColimit (coconeOfRepresentable P) where desc s := - { app X := TypeCat.ofHom fun x ↦ uliftYonedaEquiv + { app X := ↾ fun x ↦ uliftYonedaEquiv (s.ι.app (Opposite.op (Functor.elementsMk P X x))) naturality X Y f := by ext x @@ -718,7 +718,7 @@ this is the colimit cocone which identifies `F.obj X` to the colimit of noncomputable def coconeπOpCompShrinkYonedaObj (X : C) : Cocone ((CategoryOfElements.π F).op ⋙ shrinkYoneda.{w}.obj X) where pt := F.obj X - ι.app u := TypeCat.ofHom (fun t ↦ F.map (shrinkYonedaObjObjEquiv t) u.unop.snd) + ι.app u := ↾ (fun t ↦ F.map (shrinkYonedaObjObjEquiv t) u.unop.snd) ι.naturality u₁ u₂ g := by ext f obtain ⟨f, rfl⟩ := shrinkYonedaObjObjEquiv.symm.surjective f diff --git a/Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean b/Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean index 6747ce7cb7c1c5..9987c0678ac42c 100644 --- a/Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean +++ b/Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean @@ -207,7 +207,7 @@ elements in `X₁` and `X₂`. -/ noncomputable def pullbackEquiv : ToType (pullback f₁ f₂) ≃ { p : ToType X₁ × ToType X₂ // f₁ p.1 = f₂ p.2 } := (PreservesPullback.iso (forget C) f₁ f₂ ≪≫ - Types.pullbackIsoPullback (TypeCat.ofHom f₁) (TypeCat.ofHom f₂)).toEquiv + Types.pullbackIsoPullback (↾ f₁) (↾ f₂)).toEquiv /-- Constructor for elements in a pullback in a concrete category. -/ noncomputable def pullbackMk (x₁ : ToType X₁) (x₂ : ToType X₂) (h : f₁ x₁ = f₂ x₂) : @@ -223,13 +223,13 @@ lemma pullbackMk_surjective (x : ToType (pullback f₁ f₂)) : lemma pullbackMk_fst (x₁ : ToType X₁) (x₂ : ToType X₂) (h : f₁ x₁ = f₂ x₂) : pullback.fst f₁ f₂ (pullbackMk f₁ f₂ x₁ x₂ h) = x₁ := (congr_hom (PreservesPullback.iso_inv_fst (forget C) f₁ f₂) _).trans - (congr_hom (Types.pullbackIsoPullback_inv_fst (TypeCat.ofHom f₁) (TypeCat.ofHom f₂)) _) + (congr_hom (Types.pullbackIsoPullback_inv_fst (↾ f₁) (↾ f₂)) _) @[simp] lemma pullbackMk_snd (x₁ : ToType X₁) (x₂ : ToType X₂) (h : f₁ x₁ = f₂ x₂) : pullback.snd f₁ f₂ (pullbackMk f₁ f₂ x₁ x₂ h) = x₂ := (congr_hom (PreservesPullback.iso_inv_snd (forget C) f₁ f₂) _).trans - (congr_hom (Types.pullbackIsoPullback_inv_snd (TypeCat.ofHom f₁) (TypeCat.ofHom f₂)) _) + (congr_hom (Types.pullbackIsoPullback_inv_snd (↾ f₁) (↾ f₂)) _) end Pullbacks diff --git a/Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean b/Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean index 0d84e0c2ded811..f6f678d7ea0831 100644 --- a/Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean +++ b/Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean @@ -36,26 +36,26 @@ section prod @[simps obj map] def prod : C ⥤ Type w where obj a := F.obj a × G.obj a - map f := TypeCat.ofHom (fun a ↦ (F.map f a.1, G.map f a.2)) + map f := ↾ (fun a ↦ (F.map f a.1, G.map f a.2)) variable {F G} /-- The first projection of `prod F G`, onto `F`. -/ @[simps app] def prod.fst : prod F G ⟶ F where - app _ := TypeCat.ofHom (fun a ↦ a.1) + app _ := ↾ (fun a ↦ a.1) /-- The second projection of `prod F G`, onto `G`. -/ @[simps app] def prod.snd : prod F G ⟶ G where - app _ := TypeCat.ofHom (fun a ↦ a.2) + app _ := ↾ (fun a ↦ a.2) /-- Given natural transformations `F ⟶ F₁` and `F ⟶ F₂`, construct a natural transformation `F ⟶ prod F₁ F₂`. -/ @[simps] def prod.lift {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) : F ⟶ prod F₁ F₂ where - app x := TypeCat.ofHom fun y ↦ ⟨τ₁.app x y, τ₂.app x y⟩ + app x := ↾ fun y ↦ ⟨τ₁.app x y, τ₂.app x y⟩ @[simp] lemma prod.lift_fst {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) : @@ -168,7 +168,7 @@ section coprod @[simps obj map] def coprod : C ⥤ Type w where obj a := F.obj a ⊕ G.obj a - map f := TypeCat.ofHom (Sum.map (F.map f) (G.map f)) + map f := ↾ (Sum.map (F.map f) (G.map f)) map_id _ := by ext ⟨⟩ <;> simp map_comp _ _ := by ext ⟨⟩ <;> simp @@ -177,19 +177,19 @@ variable {F G} /-- The left inclusion of `F` into `coprod F G`. -/ @[simps] def coprod.inl : F ⟶ coprod F G where - app _ := TypeCat.ofHom (fun x ↦ .inl x) + app _ := ↾ (fun x ↦ .inl x) /-- The right inclusion of `G` into `coprod F G`. -/ @[simps] def coprod.inr : G ⟶ coprod F G where - app _ := TypeCat.ofHom (fun x ↦ .inr x) + app _ := ↾ (fun x ↦ .inr x) /-- Given natural transformations `F₁ ⟶ F` and `F₂ ⟶ F`, construct a natural transformation `coprod F₁ F₂ ⟶ F`. -/ @[simps] def coprod.desc {F₁ F₂ : C ⥤ Type w} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F) : coprod F₁ F₂ ⟶ F where - app a := TypeCat.ofHom (Sum.elim (τ₁.app a) (τ₂.app a)) + app a := ↾ (Sum.elim (τ₁.app a) (τ₂.app a)) naturality _ _ _ := by ext ⟨⟩ <;> simp @[simp] diff --git a/Mathlib/CategoryTheory/Limits/Shapes/Products.lean b/Mathlib/CategoryTheory/Limits/Shapes/Products.lean index 11d05d1ae38c73..04cbdcf16b5a2c 100644 --- a/Mathlib/CategoryTheory/Limits/Shapes/Products.lean +++ b/Mathlib/CategoryTheory/Limits/Shapes/Products.lean @@ -759,7 +759,7 @@ set_option backward.isDefEq.respectTransparency false in /-- `n ↦ ∏ₙ X` is left adjoint to `Hom(-, X)`. -/ def piConstAdj [Limits.HasProducts.{v} C] (X : C) : (piConst.obj X).rightOp ⊣ yoneda.obj X where - unit := { app n := TypeCat.ofHom (fun i ↦ Limits.Pi.π (fun _ : n ↦ X) i) } + unit := { app n := ↾ (fun i ↦ Limits.Pi.π (fun _ : n ↦ X) i) } counit := { app Y := (Limits.Pi.lift id).op, naturality _ _ _ := by apply Quiver.Hom.unop_inj; cat_disch } @@ -775,7 +775,7 @@ set_option backward.isDefEq.respectTransparency false in /-- `n ↦ ∐ₙ X` is left adjoint to `Hom(X, -)`. -/ def sigmaConstAdj [Limits.HasCoproducts.{v} C] (X : C) : sigmaConst.obj X ⊣ coyoneda.obj (Opposite.op X) where - unit := { app n := TypeCat.ofHom (fun i ↦ Limits.Sigma.ι (fun _ : n ↦ X) i) } + unit := { app n := ↾ (fun i ↦ Limits.Sigma.ι (fun _ : n ↦ X) i) } counit := { app Y := Limits.Sigma.desc id } /-! diff --git a/Mathlib/CategoryTheory/Limits/Types/Coequalizers.lean b/Mathlib/CategoryTheory/Limits/Types/Coequalizers.lean index c9c61d702f2b4e..bf1bc306458a8f 100644 --- a/Mathlib/CategoryTheory/Limits/Types/Coequalizers.lean +++ b/Mathlib/CategoryTheory/Limits/Types/Coequalizers.lean @@ -33,11 +33,11 @@ is a coequalizer for the pair `(f, g)`. -/ def coequalizerColimit : Limits.ColimitCocone (parallelPair f g) where cocone := - Cofork.ofπ (TypeCat.ofHom (Function.Coequalizer.mk f g)) + Cofork.ofπ (↾ (Function.Coequalizer.mk f g)) (by ext x; exact Function.Coequalizer.condition f g x) isColimit := Cofork.IsColimit.mk _ - (fun s ↦ TypeCat.ofHom (Function.Coequalizer.desc f g s.π + (fun s ↦ ↾ (Function.Coequalizer.desc f g s.π (by ext x; exact ConcreteCategory.congr_hom s.condition x))) (fun _ ↦ rfl) (fun _ _ hm ↦ by ext x; exact Quot.inductionOn x (congr_hom hm)) @@ -76,12 +76,12 @@ noncomputable def coequalizerIso : coequalizer f g ≅ (Function.Coequalizer f g @[elementwise (attr := simp)] theorem coequalizerIso_π_comp_hom : - coequalizer.π f g ≫ (coequalizerIso f g).hom = TypeCat.ofHom (Function.Coequalizer.mk f g) := + coequalizer.π f g ≫ (coequalizerIso f g).hom = ↾ (Function.Coequalizer.mk f g) := colimit.isoColimitCocone_ι_hom (coequalizerColimit f g) WalkingParallelPair.one @[elementwise (attr := simp)] theorem coequalizerIso_quot_comp_inv : - TypeCat.ofHom (Function.Coequalizer.mk f g) ≫ (coequalizerIso f g).inv = coequalizer.π f g := + ↾ (Function.Coequalizer.mk f g) ≫ (coequalizerIso f g).inv = coequalizer.π f g := rfl end CategoryTheory.Limits.Types diff --git a/Mathlib/CategoryTheory/Limits/Types/Colimits.lean b/Mathlib/CategoryTheory/Limits/Types/Colimits.lean index cfe647e4ba30b4..f8deff986c4773 100644 --- a/Mathlib/CategoryTheory/Limits/Types/Colimits.lean +++ b/Mathlib/CategoryTheory/Limits/Types/Colimits.lean @@ -39,7 +39,7 @@ with a point in `Type u` is the same as the data of a cocone (in a categorical s def coconeTypesEquiv : CoconeTypes.{u} F ≃ Cocone F where toFun c := { pt := c.pt - ι := { app j := TypeCat.ofHom (c.ι j) } } + ι := { app j := ↾ (c.ι j) } } invFun c := { pt := c.pt ι j := c.ι.app j @@ -55,7 +55,7 @@ lemma CoconeTypes.isColimit_iff (c : CoconeTypes.{u} F) : constructor · intro hc exact - ⟨{ desc s := TypeCat.ofHom (fun x => hc.desc (F.coconeTypesEquiv.symm s) x) + ⟨{ desc s := ↾ (fun x => hc.desc (F.coconeTypesEquiv.symm s) x) fac s j := by ext x exact congr_fun (hc.fac (F.coconeTypesEquiv.symm s) j) x @@ -73,9 +73,9 @@ lemma CoconeTypes.isColimit_iff (c : CoconeTypes.{u} F) : obtain ⟨j, z, rfl⟩ := F.ιColimitType_jointly_surjective z exact ConcreteCategory.congr_hom (hc.fac _ j) z · let f₁ : (F.coconeTypesEquiv c).pt ⟶ (ULift.{u} Bool) := - TypeCat.ofHom (fun _ => ULift.up true) + ↾ (fun _ => ULift.up true) let f₂ : (F.coconeTypesEquiv c).pt ⟶ (ULift.{u} Bool) := - TypeCat.ofHom (fun x => ULift.up (∃ a, F.descColimitType c a = x)) + ↾ (fun x => ULift.up (∃ a, F.descColimitType c a = x)) suffices f₁ = f₂ by have := ConcreteCategory.congr_hom this x simpa [f₁, f₂] using this @@ -220,9 +220,9 @@ theorem jointly_surjective_of_isColimit {F : J ⥤ Type u} {t : Cocone F} (h : I (x : t.pt) : ∃ j y, t.ι.app j y = x := by by_contra hx simp_rw [not_exists] at hx - apply (_ : (TypeCat.ofHom (fun _ ↦ ULift.up True) : + apply (_ : (↾ (fun _ ↦ ULift.up True) : t.pt ⟶ (ULift.{u} Prop)) ≠ - (TypeCat.ofHom (fun y ↦ ULift.up (y ≠ x)))) + (↾ (fun y ↦ ULift.up (y ≠ x)))) · refine h.hom_ext fun j ↦ ?_ ext y simp only [Functor.const_obj_obj, TypeCat.Fun.toFun_apply, comp_apply, hom_ofHom, diff --git a/Mathlib/CategoryTheory/Limits/Types/Coproducts.lean b/Mathlib/CategoryTheory/Limits/Types/Coproducts.lean index 84128b9be839ad..b2f4d170334dfa 100644 --- a/Mathlib/CategoryTheory/Limits/Types/Coproducts.lean +++ b/Mathlib/CategoryTheory/Limits/Types/Coproducts.lean @@ -199,7 +199,7 @@ def initialColimitCocone : Limits.ColimitCocone (Functor.empty (Type u)) where { pt := PEmpty ι := (Functor.uniqueFromEmpty _).inv } isColimit := - { desc := fun _ => TypeCat.ofHom (fun x => x.elim) + { desc := fun _ => ↾ (fun x => x.elim) fac := fun _ => by rintro ⟨⟨⟩⟩ uniq := fun _ _ _ => by ext x; cases x } @@ -225,14 +225,14 @@ lemma initial_iff_empty (X : Type u) : Nonempty (IsInitial X) ↔ IsEmpty X := b /-- The sum type `X ⊕ Y` forms a cocone for the binary coproduct of `X` and `Y`. -/ @[simps!] def binaryCoproductCocone (X Y : Type u) : Cocone (pair X Y) := - BinaryCofan.mk (TypeCat.ofHom Sum.inl) (TypeCat.ofHom Sum.inr) + BinaryCofan.mk (↾ Sum.inl) (↾ Sum.inr) open CategoryTheory.Limits.WalkingPair /-- The sum type `X ⊕ Y` is a binary coproduct for `X` and `Y`. -/ @[simps] def binaryCoproductColimit (X Y : Type u) : IsColimit (binaryCoproductCocone X Y) where - desc := fun s : BinaryCofan X Y => TypeCat.ofHom (Sum.elim s.inl s.inr) + desc := fun s : BinaryCofan X Y => ↾ (Sum.elim s.inl s.inr) fac _ j := Discrete.recOn j fun j => WalkingPair.casesOn j rfl rfl uniq _ _ w := by ext ⟨⟩ @@ -252,22 +252,22 @@ noncomputable def binaryCoproductIso (X Y : Type u) : Limits.coprod X Y ≅ X @[elementwise (attr := simp)] theorem binaryCoproductIso_inl_comp_hom (X Y : Type u) : - Limits.coprod.inl ≫ (binaryCoproductIso X Y).hom = TypeCat.ofHom Sum.inl := + Limits.coprod.inl ≫ (binaryCoproductIso X Y).hom = ↾ Sum.inl := colimit.isoColimitCocone_ι_hom (binaryCoproductColimitCocone X Y) ⟨WalkingPair.left⟩ @[elementwise (attr := simp)] theorem binaryCoproductIso_inr_comp_hom (X Y : Type u) : - Limits.coprod.inr ≫ (binaryCoproductIso X Y).hom = TypeCat.ofHom Sum.inr := + Limits.coprod.inr ≫ (binaryCoproductIso X Y).hom = ↾ Sum.inr := colimit.isoColimitCocone_ι_hom (binaryCoproductColimitCocone X Y) ⟨WalkingPair.right⟩ @[elementwise (attr := simp)] theorem binaryCoproductIso_inl_comp_inv (X Y : Type u) : - TypeCat.ofHom Sum.inl ≫ (binaryCoproductIso X Y).inv = Limits.coprod.inl := + ↾ Sum.inl ≫ (binaryCoproductIso X Y).inv = Limits.coprod.inl := colimit.isoColimitCocone_ι_inv (binaryCoproductColimitCocone X Y) ⟨WalkingPair.left⟩ @[elementwise (attr := simp)] theorem binaryCoproductIso_inr_comp_inv (X Y : Type u) : - TypeCat.ofHom Sum.inr ≫ (binaryCoproductIso X Y).inv = Limits.coprod.inr := + ↾ Sum.inr ≫ (binaryCoproductIso X Y).inv = Limits.coprod.inr := colimit.isoColimitCocone_ι_inv (binaryCoproductColimitCocone X Y) ⟨WalkingPair.right⟩ open Function (Injective) @@ -300,7 +300,7 @@ theorem binaryCofan_isColimit_iff {X Y : Type u} (c : BinaryCofan X Y) : exact fun _ => or_not refine ⟨BinaryCofan.IsColimit.mk _ ?_ ?_ ?_ ?_⟩ · intro T f g - refine TypeCat.ofHom (fun x => ?_) + refine ↾ (fun x => ?_) exact if h : x ∈ Set.range c.inl then f ((Equiv.ofInjective _ h₁).symm ⟨x, h⟩) else g ((Equiv.ofInjective _ h₂).symm ⟨x, (this x).resolve_left h⟩) @@ -324,7 +324,7 @@ theorem binaryCofan_isColimit_iff {X Y : Type u} (c : BinaryCofan X Y) : /-- Any monomorphism in `Type` is a coproduct injection. -/ noncomputable def isCoprodOfMono {X Y : Type u} (f : X ⟶ Y) [Mono f] : - IsColimit (BinaryCofan.mk f (TypeCat.ofHom (Subtype.val : ↑(Set.range f)ᶜ → Y))) := by + IsColimit (BinaryCofan.mk f (↾ (Subtype.val : ↑(Set.range f)ᶜ → Y))) := by apply Nonempty.some rw [binaryCofan_isColimit_iff] refine ⟨(mono_iff_injective f).mp inferInstance, Subtype.val_injective, ?_⟩ @@ -338,9 +338,9 @@ def coproductColimitCocone {J : Type v} (F : J → Type (max v u)) : Limits.ColimitCocone (Discrete.functor F) where cocone := { pt := Σ j, F j - ι := Discrete.natTrans (fun ⟨j⟩ => TypeCat.ofHom fun x => ⟨j, x⟩) } + ι := Discrete.natTrans (fun ⟨j⟩ => ↾ fun x => ⟨j, x⟩) } isColimit := - { desc := fun s => TypeCat.ofHom fun x => s.ι.app ⟨x.1⟩ x.2 + { desc := fun s => ↾ fun x => s.ι.app ⟨x.1⟩ x.2 uniq := fun s m w => by ext ⟨j, x⟩ exact ConcreteCategory.congr_hom (w ⟨j⟩) x } @@ -352,12 +352,12 @@ noncomputable def coproductIso {J : Type v} (F : J → Type (max v u)) : @[elementwise (attr := simp)] theorem coproductIso_ι_comp_hom {J : Type v} (F : J → Type (max v u)) (j : J) : - Sigma.ι F j ≫ (coproductIso F).hom = TypeCat.ofHom fun x => ⟨j, x⟩ := + Sigma.ι F j ≫ (coproductIso F).hom = ↾ fun x => ⟨j, x⟩ := colimit.isoColimitCocone_ι_hom (coproductColimitCocone F) ⟨j⟩ @[elementwise (attr := simp)] theorem coproductIso_mk_comp_inv {J : Type v} (F : J → Type (max v u)) (j : J) : - TypeCat.ofHom (fun x => ⟨j, x⟩) ≫ (coproductIso F).inv = Sigma.ι F j := + ↾ (fun x => ⟨j, x⟩) ≫ (coproductIso F).inv = Sigma.ι F j := rfl end CategoryTheory.Limits.Types diff --git a/Mathlib/CategoryTheory/Limits/Types/Equalizers.lean b/Mathlib/CategoryTheory/Limits/Types/Equalizers.lean index 5eab35b3613be3..724346bd70875f 100644 --- a/Mathlib/CategoryTheory/Limits/Types/Equalizers.lean +++ b/Mathlib/CategoryTheory/Limits/Types/Equalizers.lean @@ -34,7 +34,7 @@ The converse of `unique_of_type_equalizer`. noncomputable def typeEqualizerOfUnique (t : ∀ y : Y, g y = h y → ∃! x : X, f x = y) : IsLimit (Fork.ofι _ w) := Fork.IsLimit.mk' _ fun s => by - refine ⟨TypeCat.ofHom (fun i => ?_), ?_, ?_⟩ + refine ⟨↾ (fun i => ?_), ?_, ?_⟩ · apply Classical.choose (t (s.ι i) _) apply congr_hom s.condition i · ext i @@ -46,7 +46,7 @@ noncomputable def typeEqualizerOfUnique (t : ∀ y : Y, g y = h y → ∃! x : X /-- The converse of `type_equalizer_of_unique`. -/ theorem unique_of_type_equalizer (t : IsLimit (Fork.ofι _ w)) (y : Y) (hy : g y = h y) : ∃! x : X, f x = y := by - let y' : PUnit ⟶ Y := TypeCat.ofHom (fun _ => y) + let y' : PUnit ⟶ Y := ↾ (fun _ => y) have hy' : y' ≫ g = y' ≫ h := by ext; exact hy refine ⟨(Fork.IsLimit.lift' t _ hy').1 ⟨⟩, congr_hom (Fork.IsLimit.lift' t y' _).2 ⟨⟩, ?_⟩ intro x' hx' @@ -64,11 +64,11 @@ theorem type_equalizer_iff_unique : /-- Show that the subtype `{x : Y // g x = h x}` is an equalizer for the pair `(g,h)`. -/ def equalizerLimit : Limits.LimitCone (parallelPair g h) where - cone := Fork.ofι (TypeCat.ofHom (Subtype.val : { x : Y // g x = h x } → Y)) + cone := Fork.ofι (↾ (Subtype.val : { x : Y // g x = h x } → Y)) (by ext x; exact x.prop) isLimit := Fork.IsLimit.mk' _ fun s => - ⟨TypeCat.ofHom fun i => ⟨s.ι i, by apply congr_hom s.condition i⟩, rfl, fun hm => + ⟨↾ fun i => ⟨s.ι i, by apply congr_hom s.condition i⟩, rfl, fun hm => by ext x; exact Subtype.ext (by exact congr_hom hm x)⟩ variable (g h) @@ -79,12 +79,12 @@ noncomputable def equalizerIso : equalizer g h ≅ { x : Y // g x = h x } := @[elementwise (attr := simp)] theorem equalizerIso_hom_comp_subtype : - (equalizerIso g h).hom ≫ TypeCat.ofHom Subtype.val = equalizer.ι g h := by + (equalizerIso g h).hom ≫ ↾ Subtype.val = equalizer.ι g h := by rfl @[elementwise (attr := simp)] theorem equalizerIso_inv_comp_ι : (equalizerIso g h).inv ≫ equalizer.ι g h = - TypeCat.ofHom Subtype.val := + ↾ Subtype.val := limit.isoLimitCone_inv_π equalizerLimit WalkingParallelPair.zero end CategoryTheory.Limits.Types diff --git a/Mathlib/CategoryTheory/Limits/Types/Filtered.lean b/Mathlib/CategoryTheory/Limits/Types/Filtered.lean index 82366f1acc439b..e748aed5477433 100644 --- a/Mathlib/CategoryTheory/Limits/Types/Filtered.lean +++ b/Mathlib/CategoryTheory/Limits/Types/Filtered.lean @@ -65,7 +65,7 @@ noncomputable def isColimitOf (t : Cocone F) (hsurj : ∀ x : t.pt, ∃ i xi, x let f : ∀ (x : t.pt), F.obj (α x) := fun x => (hsurj x).choose_spec.choose have hf : ∀ (x : t.pt), x = t.ι.app _ (f x) := fun x => (hsurj x).choose_spec.choose_spec exact - { desc s := TypeCat.ofHom (fun x => s.ι.app _ (f x)) + { desc s := ↾ (fun x => s.ι.app _ (f x)) fac := fun s j => by ext y obtain ⟨k, l, g, eq⟩ := hinj _ _ _ _ (hf (t.ι.app j y)) diff --git a/Mathlib/CategoryTheory/Limits/Types/Images.lean b/Mathlib/CategoryTheory/Limits/Types/Images.lean index 422ef907392b6b..a9328dc3c3f3d3 100644 --- a/Mathlib/CategoryTheory/Limits/Types/Images.lean +++ b/Mathlib/CategoryTheory/Limits/Types/Images.lean @@ -35,7 +35,7 @@ instance [Inhabited α] : Inhabited (Image f) where default := ⟨f default, ⟨ /-- the inclusion of `Image f` into the target -/ def Image.ι : Image f ⟶ β := - TypeCat.ofHom (Subtype.val) + ↾ (Subtype.val) instance : Mono (Image.ι f) := (mono_iff_injective _).2 Subtype.val_injective @@ -44,7 +44,7 @@ variable {f} /-- the universal property for the image factorisation -/ noncomputable def Image.lift (F' : MonoFactorisation f) : Image f ⟶ F'.I := - TypeCat.ofHom (fun x => F'.e (Classical.indefiniteDescription _ x.2).1 : Image f → F'.I) + ↾ (fun x => F'.e (Classical.indefiniteDescription _ x.2).1 : Image f → F'.I) theorem Image.lift_fac (F' : MonoFactorisation f) : Image.lift F' ≫ F'.m = Image.ι f := by ext x @@ -58,7 +58,7 @@ end def monoFactorisation : MonoFactorisation f where I := Image f m := Image.ι f - e := TypeCat.ofHom (Set.rangeFactorization f) + e := ↾ (Set.rangeFactorization f) /-- the factorisation through a mono has the universal property of the image. -/ noncomputable def isImage : IsImage (monoFactorisation f) where @@ -74,7 +74,7 @@ instance : HasImages (Type u) where instance : HasImageMaps (Type u) where has_image_map {f g} st := HasImageMap.transport st (monoFactorisation f.hom) (isImage g.hom) - (TypeCat.ofHom (fun x => ⟨st.right x.val, ⟨st.left (Classical.choose x.2), by + (↾ (fun x => ⟨st.right x.val, ⟨st.left (Classical.choose x.2), by rw [elementwise_of% st.w] rw [Classical.choose_spec x.property]⟩⟩)) rfl diff --git a/Mathlib/CategoryTheory/Limits/Types/Limits.lean b/Mathlib/CategoryTheory/Limits/Types/Limits.lean index f94c5f88cc763f..58b7c872d57bdd 100644 --- a/Mathlib/CategoryTheory/Limits/Types/Limits.lean +++ b/Mathlib/CategoryTheory/Limits/Types/Limits.lean @@ -31,7 +31,7 @@ variable {J : Type v} [Category.{w} J] {F : J ⥤ Type u} construct a cone over F with `PUnit` as the cone point. -/ def coneOfSection {s} (hs : s ∈ F.sections) : Cone F where pt := PUnit - π := { app j := TypeCat.ofHom (fun _ ↦ s j), naturality _ _ f := by ext; exact (hs f).symm } + π := { app j := ↾ (fun _ ↦ s j), naturality _ _ f := by ext; exact (hs f).symm } /-- Given a cone over a functor F into `Type*` and an element in the cone point, construct a section of F. -/ @@ -44,10 +44,10 @@ theorem isLimit_iff (c : Cone F) : · let cs := coneOfSection hs exact ⟨t.lift cs ⟨⟩, fun j ↦ congr_hom (t.fac cs j) ⟨⟩, fun x hx ↦ congr_hom (CC := fun X ↦ X) - (t.uniq cs (TypeCat.ofHom (fun _ ↦ x)) fun j ↦ by ext; exact hx j) ⟨⟩⟩ + (t.uniq cs (↾ (fun _ ↦ x)) fun j ↦ by ext; exact hx j) ⟨⟩⟩ · have := fun c y ↦ h _ (sectionOfCone c y).2 choose x hx using fun c y ↦ h _ (sectionOfCone c y).2 - exact ⟨fun d ↦ TypeCat.ofHom (x d), fun c j ↦ by ext y; exact (hx c y).1 j, + exact ⟨fun d ↦ ↾ (x d), fun c j ↦ by ext y; exact (hx c y).1 j, fun c f hf ↦ by ext y; exact (hx c y).2 (f y) (fun j ↦ congr_hom (hf j) y)⟩ theorem isLimit_iff_bijective_sectionOfCone (c : Cone F) : @@ -62,7 +62,7 @@ noncomputable def isLimitEquivSections {c : Cone F} (t : IsLimit c) : toFun := sectionOfCone c invFun s := t.lift (coneOfSection s.2) ⟨⟩ left_inv x := (congr_hom (t.uniq (coneOfSection _) - (TypeCat.ofHom (fun _ ↦ x)) fun _ ↦ rfl) ⟨⟩).symm + (↾ (fun _ ↦ x)) fun _ ↦ rfl) ⟨⟩).symm right_inv s := Subtype.ext (funext fun j ↦ congr_hom (t.fac (coneOfSection s.2) j) ⟨⟩) @[simp] @@ -109,7 +109,7 @@ implemented as flat sections of a pi type noncomputable def limitCone : Cone F where pt := Shrink F.sections π := - { app j := TypeCat.ofHom (fun u => ((equivShrink F.sections).symm u).val j) } + { app j := ↾ (fun u => ((equivShrink F.sections).symm u).val j) } @[ext] lemma limitCone_pt_ext {x y : (limitCone F).pt} @@ -119,7 +119,7 @@ lemma limitCone_pt_ext {x y : (limitCone F).pt} /-- (internal implementation) the fact that the proposed limit cone is the limit -/ @[simps] noncomputable def limitConeIsLimit : IsLimit (limitCone.{v, u} F) where - lift s := TypeCat.ofHom fun v ↦ equivShrink F.sections + lift s := ↾ fun v ↦ equivShrink F.sections { val := fun j => s.π.app j v property := fun f => congr_hom (Cone.w s f) _ } uniq := fun _ _ w => by @@ -145,12 +145,12 @@ implemented as flat sections of a pi type @[simps] noncomputable def limitCone (F : J ⥤ Type (max v u)) : Cone F where pt := F.sections - π := { app j := TypeCat.ofHom (fun u => u.val j) } + π := { app j := ↾ (fun u => u.val j) } /-- (internal implementation) the fact that the proposed limit cone is the limit -/ @[simps] noncomputable def limitConeIsLimit (F : J ⥤ Type (max v u)) : IsLimit (limitCone F) where - lift s := TypeCat.ofHom fun v ↦ + lift s := ↾ fun v ↦ { val := fun j => s.π.app j v property := fun f => congr_hom (Cone.w s f) _ } uniq := fun _ _ w => by diff --git a/Mathlib/CategoryTheory/Limits/Types/Products.lean b/Mathlib/CategoryTheory/Limits/Types/Products.lean index 7210bcbf1e3ac0..e4507bad996aac 100644 --- a/Mathlib/CategoryTheory/Limits/Types/Products.lean +++ b/Mathlib/CategoryTheory/Limits/Types/Products.lean @@ -101,22 +101,22 @@ open CategoryTheory.Limits.WalkingPair /-- The product type `X × Y` forms a cone for the binary product of `X` and `Y`. -/ @[simps! pt] def binaryProductCone (X Y : Type u) : BinaryFan X Y := - BinaryFan.mk (TypeCat.ofHom _root_.Prod.fst) (TypeCat.ofHom _root_.Prod.snd) + BinaryFan.mk (↾ _root_.Prod.fst) (↾ _root_.Prod.snd) @[simp] theorem binaryProductCone_fst (X Y : Type u) : - (binaryProductCone X Y).fst = TypeCat.ofHom _root_.Prod.fst := + (binaryProductCone X Y).fst = ↾ _root_.Prod.fst := rfl @[simp] theorem binaryProductCone_snd (X Y : Type u) : - (binaryProductCone X Y).snd = TypeCat.ofHom _root_.Prod.snd := + (binaryProductCone X Y).snd = ↾ _root_.Prod.snd := rfl /-- The product type `X × Y` is a binary product for `X` and `Y`. -/ @[simps] def binaryProductLimit (X Y : Type u) : IsLimit (binaryProductCone X Y) where - lift (s : BinaryFan X Y) := TypeCat.ofHom (fun x => (s.fst x, s.snd x)) + lift (s : BinaryFan X Y) := ↾ (fun x => (s.fst x, s.snd x)) fac _ j := Discrete.recOn j fun j => WalkingPair.casesOn j rfl rfl uniq _ _ w := by ext x @@ -136,22 +136,22 @@ noncomputable def binaryProductIso (X Y : Type u) : Limits.prod X Y ≅ X × Y : @[elementwise (attr := simp)] theorem binaryProductIso_hom_comp_fst (X Y : Type u) : - (binaryProductIso X Y).hom ≫ TypeCat.ofHom _root_.Prod.fst = Limits.prod.fst := + (binaryProductIso X Y).hom ≫ ↾ _root_.Prod.fst = Limits.prod.fst := limit.isoLimitCone_hom_π (binaryProductLimitCone X Y) ⟨WalkingPair.left⟩ @[elementwise (attr := simp)] theorem binaryProductIso_hom_comp_snd (X Y : Type u) : - (binaryProductIso X Y).hom ≫ TypeCat.ofHom _root_.Prod.snd = Limits.prod.snd := + (binaryProductIso X Y).hom ≫ ↾ _root_.Prod.snd = Limits.prod.snd := limit.isoLimitCone_hom_π (binaryProductLimitCone X Y) ⟨WalkingPair.right⟩ @[elementwise (attr := simp)] theorem binaryProductIso_inv_comp_fst (X Y : Type u) : - (binaryProductIso X Y).inv ≫ Limits.prod.fst = TypeCat.ofHom _root_.Prod.fst := + (binaryProductIso X Y).inv ≫ Limits.prod.fst = ↾ _root_.Prod.fst := limit.isoLimitCone_inv_π (binaryProductLimitCone X Y) ⟨WalkingPair.left⟩ @[elementwise (attr := simp)] theorem binaryProductIso_inv_comp_snd (X Y : Type u) : - (binaryProductIso X Y).inv ≫ Limits.prod.snd = TypeCat.ofHom _root_.Prod.snd := + (binaryProductIso X Y).inv ≫ Limits.prod.snd = ↾ _root_.Prod.snd := limit.isoLimitCone_inv_π (binaryProductLimitCone X Y) ⟨WalkingPair.right⟩ /-- The functor which sends `X, Y` to the product type `X × Y`. -/ @@ -160,11 +160,11 @@ def binaryProductFunctor : Type u ⥤ Type u ⥤ Type u where obj X := { obj := fun Y => X × Y map := fun {_ Y₂} f => (binaryProductLimit X Y₂).lift - (BinaryFan.mk (TypeCat.ofHom _root_.Prod.fst) (TypeCat.ofHom _root_.Prod.snd ≫ f)) } + (BinaryFan.mk (↾ _root_.Prod.fst) (↾ _root_.Prod.snd ≫ f)) } map {X₁ X₂} f := { app := fun Y => - (binaryProductLimit X₂ Y).lift (BinaryFan.mk (TypeCat.ofHom _root_.Prod.fst ≫ f) - (TypeCat.ofHom _root_.Prod.snd)) } + (binaryProductLimit X₂ Y).lift (BinaryFan.mk (↾ _root_.Prod.fst ≫ f) + (↾ _root_.Prod.snd)) } set_option backward.isDefEq.respectTransparency false in /-- The product functor given by the instance `HasBinaryProducts (Type u)` is isomorphic to the @@ -186,9 +186,9 @@ def productLimitCone {J : Type v} (F : J → Type (max v u)) : Limits.LimitCone (Discrete.functor F) where cone := { pt := (∀ j, F j) - π := Discrete.natTrans (fun ⟨j⟩ => TypeCat.ofHom (fun f => f j)) } + π := Discrete.natTrans (fun ⟨j⟩ => ↾ (fun f => f j)) } isLimit := - { lift := fun s => TypeCat.ofHom fun x j => s.π.app ⟨j⟩ x + { lift := fun s => ↾ fun x j => s.π.app ⟨j⟩ x uniq := fun _ _ w => by ext x j exact ConcreteCategory.congr_hom (w ⟨j⟩) x } @@ -200,7 +200,7 @@ noncomputable def productIso {J : Type v} (F : J → Type (max v u)) : @[elementwise (attr := simp)] theorem productIso_hom_comp_eval {J : Type v} (F : J → Type (max v u)) (j : J) : - (productIso.{v, u} F).hom ≫ TypeCat.ofHom (fun f => f j) = Pi.π F j := by + (productIso.{v, u} F).hom ≫ ↾ (fun f => f j) = Pi.π F j := by rfl -- -- Used to be generated by `elementwise` @@ -211,7 +211,7 @@ theorem productIso_hom_comp_eval {J : Type v} (F : J → Type (max v u)) (j : J) @[elementwise (attr := simp)] theorem productIso_inv_comp_π {J : Type v} (F : J → Type max v u) (j : J) : - (productIso.{v, u} F).inv ≫ Pi.π F j = TypeCat.ofHom fun f => f j := + (productIso.{v, u} F).inv ≫ Pi.π F j = ↾ fun f => f j := limit.isoLimitCone_inv_π (productLimitCone.{v, u} F) ⟨j⟩ namespace Small @@ -226,10 +226,10 @@ noncomputable def productLimitCone : cone := { pt := Shrink (∀ j, F j) π := Discrete.natTrans (fun ⟨j⟩ => - TypeCat.ofHom (fun f => (equivShrink (∀ j, F j)).symm f j)) } + ↾ (fun f => (equivShrink (∀ j, F j)).symm f j)) } isLimit := have : Small.{u} (∀ j, F j) := inferInstance - { lift := fun s => TypeCat.ofHom fun x => (equivShrink _) (fun j => s.π.app ⟨j⟩ x) + { lift := fun s => ↾ fun x => (equivShrink _) (fun j => s.π.app ⟨j⟩ x) uniq := fun s m w => ConcreteCategory.hom_ext _ _ fun x => Shrink.ext (funext fun j => by simpa using ConcreteCategory.congr_hom (w ⟨j⟩) x) } @@ -241,14 +241,14 @@ noncomputable def productIso : @[elementwise (attr := simp)] theorem productIso_hom_comp_eval (j : J) : - (productIso.{v, u} F).hom ≫ TypeCat.ofHom (fun f => (equivShrink (∀ j, F j)).symm f j) = + (productIso.{v, u} F).hom ≫ ↾ (fun f => (equivShrink (∀ j, F j)).symm f j) = Pi.π F j := limit.isoLimitCone_hom_π (productLimitCone.{v, u} F) ⟨j⟩ @[elementwise (attr := simp)] theorem productIso_inv_comp_π (j : J) : (productIso.{v, u} F).inv ≫ Pi.π F j = - TypeCat.ofHom (fun f => ((equivShrink (∀ j, F j)).symm f) j) := + ↾ (fun f => ((equivShrink (∀ j, F j)).symm f) j) := limit.isoLimitCone_inv_π (productLimitCone.{v, u} F) ⟨j⟩ end Small diff --git a/Mathlib/CategoryTheory/Limits/Types/Pullbacks.lean b/Mathlib/CategoryTheory/Limits/Types/Pullbacks.lean index 9a638a6039594e..c5ba3399d8494a 100644 --- a/Mathlib/CategoryTheory/Limits/Types/Pullbacks.lean +++ b/Mathlib/CategoryTheory/Limits/Types/Pullbacks.lean @@ -41,8 +41,8 @@ example (p : PullbackObj f g) : X × Y := This is bundled with the `IsLimit` data as `pullbackLimitCone f g`. -/ abbrev pullbackCone : Limits.PullbackCone f g := - PullbackCone.mk (TypeCat.ofHom (fun p : PullbackObj f g => p.1.1)) - (TypeCat.ofHom (fun p => p.1.2)) (by ext p; exact p.2) + PullbackCone.mk (↾ (fun p : PullbackObj f g => p.1.1)) + (↾ (fun p => p.1.2)) (by ext p; exact p.2) /-- The explicit pullback in the category of types, bundled up as a `LimitCone` for given `f` and `g`. @@ -51,7 +51,7 @@ for given `f` and `g`. def pullbackLimitCone (f : X ⟶ Z) (g : Y ⟶ Z) : Limits.LimitCone (cospan f g) where cone := pullbackCone f g isLimit := - PullbackCone.isLimitAux _ (fun s => TypeCat.ofHom + PullbackCone.isLimitAux _ (fun s => ↾ fun x => ⟨⟨s.fst x, s.snd x⟩, congr_hom s.condition x⟩) (by aesop) (by aesop) fun _ _ w => ConcreteCategory.ext <| TypeCat.Fun.ext <| funext fun x => Subtype.ext <| @@ -145,14 +145,14 @@ theorem pullbackIsoPullback_hom_snd (p : pullback f g) : @[elementwise (attr := simp)] theorem pullbackIsoPullback_inv_fst : (pullbackIsoPullback f g).inv ≫ pullback.fst _ _ = - TypeCat.ofHom (fun p => (p.1 : X × Y).fst) := by + ↾ (fun p => (p.1 : X × Y).fst) := by ext exact PullbackCone.IsLimit.equivPullbackObj_symm_apply_fst (pullbackIsPullback f g) _ @[elementwise (attr := simp)] theorem pullbackIsoPullback_inv_snd : (pullbackIsoPullback f g).inv ≫ pullback.snd _ _ = - TypeCat.ofHom (fun p => (p.1 : X × Y).snd) := by + ↾ (fun p => (p.1 : X × Y).snd) := by ext exact PullbackCone.IsLimit.equivPullbackObj_symm_apply_snd (pullbackIsPullback f g) _ @@ -221,7 +221,7 @@ lemma isPullback_iff : · intro h exact ⟨h.w, fun x₁ y₁ ⟨h₁, h₂⟩ ↦ ext_of_isPullback h h₁ h₂, exists_of_isPullback h⟩ · rintro ⟨w, h₁, h₂⟩ - let φ : X₁ ⟶ PullbackObj r b := TypeCat.ofHom fun x₁ ↦ ⟨⟨t x₁, l x₁⟩, congr_hom w x₁⟩ + let φ : X₁ ⟶ PullbackObj r b := ↾ fun x₁ ↦ ⟨⟨t x₁, l x₁⟩, congr_hom w x₁⟩ have hφ : IsIso φ := by rw [isIso_iff_bijective] constructor diff --git a/Mathlib/CategoryTheory/Limits/Types/Pushouts.lean b/Mathlib/CategoryTheory/Limits/Types/Pushouts.lean index 7cbbf3f11907a5..6a066b540236b8 100644 --- a/Mathlib/CategoryTheory/Limits/Types/Pushouts.lean +++ b/Mathlib/CategoryTheory/Limits/Types/Pushouts.lean @@ -54,11 +54,11 @@ namespace Pushout /-- The left inclusion in the constructed pushout `Pushout f g`. -/ @[simp] -def inl : X₁ ⟶ Pushout f g := TypeCat.ofHom (fun x => Quot.mk _ (Sum.inl x)) +def inl : X₁ ⟶ Pushout f g := ↾ (fun x => Quot.mk _ (Sum.inl x)) /-- The right inclusion in the constructed pushout `Pushout f g`. -/ @[simp] -def inr : X₂ ⟶ Pushout f g := TypeCat.ofHom (fun x => Quot.mk _ (Sum.inr x)) +def inr : X₂ ⟶ Pushout f g := ↾ (fun x => Quot.mk _ (Sum.inr x)) lemma condition : f ≫ inl f g = g ≫ inr f g := by ext x @@ -70,7 +70,7 @@ def cocone : PushoutCocone f g := PushoutCocone.mk _ _ (condition f g) /-- The cocone `cocone f g` is colimit. -/ def isColimitCocone : IsColimit (cocone f g) := - PushoutCocone.IsColimit.mk _ (fun s => TypeCat.ofHom (Quot.lift (fun x => match x with + PushoutCocone.IsColimit.mk _ (fun s => ↾ (Quot.lift (fun x => match x with | Sum.inl x₁ => s.inl x₁ | Sum.inr x₂ => s.inr x₂) (by rintro _ _ ⟨t⟩ diff --git a/Mathlib/CategoryTheory/Limits/Types/Yoneda.lean b/Mathlib/CategoryTheory/Limits/Types/Yoneda.lean index ee420395552c78..77188e4ebf3447 100644 --- a/Mathlib/CategoryTheory/Limits/Types/Yoneda.lean +++ b/Mathlib/CategoryTheory/Limits/Types/Yoneda.lean @@ -79,10 +79,10 @@ set_option backward.isDefEq.respectTransparency false in @[simps] noncomputable def limitCompCoyonedaIsoCone (F : J ⥤ C) (X : C) : limit (F ⋙ coyoneda.obj (op X)) ≅ ((const J).obj X ⟶ F) where - hom := TypeCat.ofHom fun a ↦ { + hom := ↾ fun a ↦ { app j := limit.π (F ⋙ coyoneda.obj (op X)) j a naturality _ _ _ := by simpa using (limit.w_apply _ _ _).symm } - inv := TypeCat.ofHom fun t ↦ limit.lift _ (Types.coneOfSection (s := t.app) <| by + inv := ↾ fun t ↦ limit.lift _ (Types.coneOfSection (s := t.app) <| by simp [Functor.sections, ← t.naturality]) ⟨⟩ attribute [local simp←] comp_apply in @@ -102,10 +102,10 @@ set_option backward.isDefEq.respectTransparency false in @[simps] noncomputable def limitCompYonedaIsoCocone (F : J ⥤ C) (X : C) : limit (F.op ⋙ yoneda.obj X) ≅ (F ⟶ (const J).obj X) where - hom := TypeCat.ofHom fun a ↦ { + hom := ↾ fun a ↦ { app j := limit.π (F.op ⋙ yoneda.obj X) ⟨j⟩ a naturality _ _ f := by simpa using (limit.w_apply (F.op ⋙ yoneda.obj X) f.op a) } - inv := TypeCat.ofHom fun t ↦ limit.lift _ (Types.coneOfSection (s := fun j ↦ t.app j.unop) <| by + inv := ↾ fun t ↦ limit.lift _ (Types.coneOfSection (s := fun j ↦ t.app j.unop) <| by simp [Functor.sections]) ⟨⟩ attribute [local simp←] comp_apply in diff --git a/Mathlib/CategoryTheory/Limits/Yoneda.lean b/Mathlib/CategoryTheory/Limits/Yoneda.lean index 38cbc4d2dac52b..2f1f97eac7f2f2 100644 --- a/Mathlib/CategoryTheory/Limits/Yoneda.lean +++ b/Mathlib/CategoryTheory/Limits/Yoneda.lean @@ -38,14 +38,14 @@ variable {C : Type u} [Category.{v} C] @[simps] def colimitCocone (X : Cᵒᵖ) : Cocone (coyoneda.obj X) where pt := PUnit - ι := { app _ := TypeCat.ofHom (fun _ ↦ by cat_disch) } + ι := { app _ := ↾ (fun _ ↦ by cat_disch) } set_option backward.isDefEq.respectTransparency false in /-- The proposed colimit cocone over `coyoneda.obj X` is a colimit cocone. -/ @[simps] def colimitCoconeIsColimit (X : Cᵒᵖ) : IsColimit (colimitCocone X) where - desc s := TypeCat.ofHom (fun _ ↦ s.ι.app (unop X) (𝟙 _)) + desc s := ↾ (fun _ ↦ s.ι.app (unop X) (𝟙 _)) fac s Y := by ext f simpa using congr_hom (s.w f).symm (𝟙 (unop X)) diff --git a/Mathlib/CategoryTheory/Monad/Types.lean b/Mathlib/CategoryTheory/Monad/Types.lean index e180db0a63d71b..c7fe70d306deea 100644 --- a/Mathlib/CategoryTheory/Monad/Types.lean +++ b/Mathlib/CategoryTheory/Monad/Types.lean @@ -35,9 +35,9 @@ variable (m : Type u → Type u) [_root_.Monad m] [LawfulMonad m] @[simps! obj map η_app μ_app] def ofTypeMonad : Monad (Type u) where toFunctor := ofTypeFunctor m - η := ⟨fun X ↦ TypeCat.ofHom (@pure m _ X), fun _ _ f => by + η := ⟨fun X ↦ ↾ (@pure m _ X), fun _ _ f => by ext x; exact (LawfulApplicative.map_pure f x).symm⟩ - μ := ⟨fun X ↦ TypeCat.ofHom (@joinM m _ X), fun _ _ _ => by ext _; exact joinM_map_map _ _⟩ + μ := ⟨fun X ↦ ↾ (@joinM m _ X), fun _ _ _ => by ext _; exact joinM_map_map _ _⟩ assoc _ := by ext; exact joinM_map_joinM _ left_unit _ := by ext; exact joinM_pure _ right_unit _ := by ext; exact joinM_map_pure _ @@ -50,7 +50,7 @@ category-theoretic version, provided the monad is lawful. def kleisliCatEquivKleisli : KleisliCat m ≌ Kleisli (ofTypeMonad m) where functor := { obj X := Kleisli.mk _ X - map f := ⟨TypeCat.ofHom f⟩ + map f := ⟨↾ f⟩ map_id := fun _ => rfl map_comp := fun f g => by ext diff --git a/Mathlib/CategoryTheory/Monoidal/Braided/Reflection.lean b/Mathlib/CategoryTheory/Monoidal/Braided/Reflection.lean index 8ad7d3e7770b02..ede399170ce9e8 100644 --- a/Mathlib/CategoryTheory/Monoidal/Braided/Reflection.lean +++ b/Mathlib/CategoryTheory/Monoidal/Braided/Reflection.lean @@ -161,7 +161,7 @@ theorem isIso_tfae : List.TFAE refine IsIso.comp_isIso' inferInstance ?_ constructor -- We give the inverse of the bottom map in the stack of commutative squares: - refine ⟨TypeCat.ofHom (fun f ↦ R.map ((adj.homEquiv _ _).symm f)), ?_, by ext; simp⟩ + refine ⟨↾ (fun f ↦ R.map ((adj.homEquiv _ _).symm f)), ?_, by ext; simp⟩ ext f simp only [comp_obj, flip_obj_obj, yoneda_obj_obj, id_obj, flip_map_app, yoneda_obj_map, Quiver.Hom.unop_op, Adjunction.homEquiv_counit, map_comp, TypeCat.Fun.toFun_apply, comp_apply, diff --git a/Mathlib/CategoryTheory/Monoidal/Closed/FunctorToTypes.lean b/Mathlib/CategoryTheory/Monoidal/Closed/FunctorToTypes.lean index 7f40174774566d..4ef42b8171b400 100644 --- a/Mathlib/CategoryTheory/Monoidal/Closed/FunctorToTypes.lean +++ b/Mathlib/CategoryTheory/Monoidal/Closed/FunctorToTypes.lean @@ -42,7 +42,7 @@ set_option backward.isDefEq.respectTransparency false in @[simps! obj_obj obj_map map_app] def rightAdj : (C ⥤ Type (max w v u)) ⥤ C ⥤ Type (max w v u) where obj G := F.functorHom G - map f := { app X := TypeCat.ofHom fun a ↦ { + map f := { app X := ↾ fun a ↦ { app d b := a.app d b ≫ f.app d naturality g h := by have := a.naturality g h diff --git a/Mathlib/CategoryTheory/Monoidal/Closed/Types.lean b/Mathlib/CategoryTheory/Monoidal/Closed/Types.lean index 74a309643a1087..8e8c00ae1f26d5 100644 --- a/Mathlib/CategoryTheory/Monoidal/Closed/Types.lean +++ b/Mathlib/CategoryTheory/Monoidal/Closed/Types.lean @@ -37,8 +37,8 @@ section MonoidalClosed for any `X : Type v₁`. -/ def Types.tensorProductAdjunction (X : Type v₁) : tensorLeft X ⊣ coyoneda.obj (Opposite.op X) where - unit := { app Z := TypeCat.ofHom fun z ↦ TypeCat.ofHom fun x => ⟨x, z⟩ } - counit := { app _ := TypeCat.ofHom (fun xf => xf.2.hom xf.1) } + unit := { app Z := ↾ fun z ↦ ↾ fun x => ⟨x, z⟩ } + counit := { app _ := ↾ (fun xf => xf.2.hom xf.1) } instance (X : Type v₁) : (tensorLeft X).IsLeftAdjoint := ⟨_, ⟨Types.tensorProductAdjunction X⟩⟩ diff --git a/Mathlib/CategoryTheory/Monoidal/Functor/Types.lean b/Mathlib/CategoryTheory/Monoidal/Functor/Types.lean index 9110000a45e9b9..42846b6defbbf8 100644 --- a/Mathlib/CategoryTheory/Monoidal/Functor/Types.lean +++ b/Mathlib/CategoryTheory/Monoidal/Functor/Types.lean @@ -32,8 +32,8 @@ attribute [local simp] map_seq seq_map_assoc types_tensorObj_def types_tensorUni between categories of types. -/ @[simps] instance : (ofTypeFunctor F).LaxMonoidal where - ε := TypeCat.ofHom (fun _ ↦ (pure PUnit.unit : F _)) - μ _ _ := TypeCat.ofHom (fun p ↦ (Prod.mk <$> p.1 <*> p.2 : F _)) + ε := ↾ (fun _ ↦ (pure PUnit.unit : F _)) + μ _ _ := ↾ (fun p ↦ (Prod.mk <$> p.1 <*> p.2 : F _)) end diff --git a/Mathlib/CategoryTheory/Monoidal/Grp_.lean b/Mathlib/CategoryTheory/Monoidal/Grp_.lean index e65ca51aedc917..2e96f789a18593 100644 --- a/Mathlib/CategoryTheory/Monoidal/Grp_.lean +++ b/Mathlib/CategoryTheory/Monoidal/Grp_.lean @@ -350,7 +350,7 @@ lemma ext {X : C} (h₁ h₂ : GrpObj X) (H : h₁.toMonObj = h₂.toMonObj) : h @[implicit_reducible] def ofInvertible (G : C) [MonObj G] (h : ∀ X (f : X ⟶ G), Invertible f) : GrpObj G where inv := Yoneda.fullyFaithful.preimage - ⟨fun X ↦ TypeCat.ofHom (fun f ↦ (h X.unop f).invOf), fun X Y f ↦ by + ⟨fun X ↦ ↾ (fun f ↦ (h X.unop f).invOf), fun X Y f ↦ by ext g simp only [yoneda_obj_obj, yoneda_obj_map, TypeCat.Fun.toFun_apply, comp_apply, ConcreteCategory.hom_ofHom, TypeCat.Fun.coe_mk, invOf_eq_iff_left] diff --git a/Mathlib/CategoryTheory/Monoidal/Internal/Types/Basic.lean b/Mathlib/CategoryTheory/Monoidal/Internal/Types/Basic.lean index a22b761cb9434c..b216afe01fb7cd 100644 --- a/Mathlib/CategoryTheory/Monoidal/Internal/Types/Basic.lean +++ b/Mathlib/CategoryTheory/Monoidal/Internal/Types/Basic.lean @@ -51,12 +51,12 @@ noncomputable def inverse : MonCat.{u} ⥤ Mon (Type u) where obj A := { X := A mon := - { one := TypeCat.ofHom (fun _ => 1) - mul := TypeCat.ofHom (fun p => p.1 * p.2) + { one := ↾ (fun _ => 1) + mul := ↾ (fun p => p.1 * p.2) one_mul := by cat_disch mul_one := by cat_disch mul_assoc := by ext ⟨⟨x, y⟩, z⟩; simp [_root_.mul_assoc] } } - map f := .mk' (TypeCat.ofHom f) + map f := .mk' (↾ f) (one_f := by #adaptation_note /-- Prior to https://github.com/leanprover/lean4/pull/12244 this argument was provided by the auto_param. -/ diff --git a/Mathlib/CategoryTheory/Monoidal/Internal/Types/Grp_.lean b/Mathlib/CategoryTheory/Monoidal/Internal/Types/Grp_.lean index 5b859b802ef260..7045dc76ea640a 100644 --- a/Mathlib/CategoryTheory/Monoidal/Internal/Types/Grp_.lean +++ b/Mathlib/CategoryTheory/Monoidal/Internal/Types/Grp_.lean @@ -43,7 +43,7 @@ noncomputable def inverse : GrpCat.{u} ⥤ Grp (Type u) where obj A := { MonTypeEquivalenceMon.inverse.obj ((forget₂ GrpCat MonCat).obj A) with grp := - { inv := TypeCat.ofHom ((·⁻¹) : A → A) + { inv := ↾ ((·⁻¹) : A → A) left_inv := by ext x exact inv_mul_cancel (G := A) x diff --git a/Mathlib/CategoryTheory/Monoidal/Types/Coyoneda.lean b/Mathlib/CategoryTheory/Monoidal/Types/Coyoneda.lean index 17f78683a30f0a..13aaa091162239 100644 --- a/Mathlib/CategoryTheory/Monoidal/Types/Coyoneda.lean +++ b/Mathlib/CategoryTheory/Monoidal/Types/Coyoneda.lean @@ -24,8 +24,8 @@ attribute [local simp] types_tensorObj_def types_tensorUnit_def in instance (C : Type u) [Category.{v} C] [MonoidalCategory C] : (coyoneda.obj (op (𝟙_ C))).LaxMonoidal := Functor.LaxMonoidal.ofTensorHom - (ε := TypeCat.ofHom (fun _ ↦ 𝟙 _)) - (μ := fun X Y ↦ TypeCat.ofHom (fun p ↦ (λ_ (𝟙_ C)).inv ≫ (p.1 ⊗ₘ p.2))) + (ε := ↾ (fun _ ↦ 𝟙 _)) + (μ := fun X Y ↦ ↾ (fun p ↦ (λ_ (𝟙_ C)).inv ≫ (p.1 ⊗ₘ p.2))) (μ_natural := by cat_disch) (associativity := fun X Y Z => by ext ⟨⟨f, g⟩, h⟩; dsimp at f g h diff --git a/Mathlib/CategoryTheory/MorphismProperty/Concrete.lean b/Mathlib/CategoryTheory/MorphismProperty/Concrete.lean index e90d5fb8f5bf97..9fd57d552cfdf5 100644 --- a/Mathlib/CategoryTheory/MorphismProperty/Concrete.lean +++ b/Mathlib/CategoryTheory/MorphismProperty/Concrete.lean @@ -120,16 +120,16 @@ def functorialSurjectiveInjectiveFactorizationData : FunctorialSurjectiveInjectiveFactorizationData (Type u) where Z := { obj := fun f => Subtype (Set.range f.hom.hom) - map := fun φ => TypeCat.ofHom fun y => ⟨φ.right y.1, by + map := fun φ => ↾ fun y => ⟨φ.right y.1, by obtain ⟨_, x, rfl⟩ := y exact ⟨φ.left x, congr_hom φ.w x⟩ ⟩ } i := - { app := fun f => TypeCat.ofHom fun x => ⟨f.hom x, ⟨x, rfl⟩⟩ + { app := fun f => ↾ fun x => ⟨f.hom x, ⟨x, rfl⟩⟩ naturality := fun f g φ => by ext x exact congr_hom φ.w x } p := - { app := fun _ => TypeCat.ofHom (fun y => y.1) + { app := fun _ => ↾ (fun y => y.1) naturality := by intros; rfl; } fac := rfl hi := by diff --git a/Mathlib/CategoryTheory/Preadditive/Injective/Basic.lean b/Mathlib/CategoryTheory/Preadditive/Injective/Basic.lean index 4c94a18bb04d9f..b4fb73c266192f 100644 --- a/Mathlib/CategoryTheory/Preadditive/Injective/Basic.lean +++ b/Mathlib/CategoryTheory/Preadditive/Injective/Basic.lean @@ -105,7 +105,7 @@ theorem iso_iff {P Q : C} (i : P ≅ Q) : Injective P ↔ Injective Q := /-- The axiom of choice says that every nonempty type is an injective object in `Type`. -/ instance (X : Type u₁) [Nonempty X] : Injective X where factors g f mono := - ⟨TypeCat.ofHom fun z => by + ⟨↾ fun z => by classical exact if h : z ∈ Set.range f then g (Classical.choose h) else Nonempty.some inferInstance, by @@ -122,7 +122,7 @@ instance Type.enoughInjectives : EnoughInjectives (Type u₁) where Nonempty.intro { J := WithBot X injective := inferInstance - f := TypeCat.ofHom WithBot.some + f := ↾ WithBot.some mono := by rw [mono_iff_injective] exact WithBot.coe_injective } diff --git a/Mathlib/CategoryTheory/Preadditive/Projective/Basic.lean b/Mathlib/CategoryTheory/Preadditive/Projective/Basic.lean index 063ac403eca1fd..4f56100aae2daf 100644 --- a/Mathlib/CategoryTheory/Preadditive/Projective/Basic.lean +++ b/Mathlib/CategoryTheory/Preadditive/Projective/Basic.lean @@ -115,7 +115,7 @@ theorem iso_iff {P Q : C} (i : P ≅ Q) : Projective P ↔ Projective Q := instance (X : Type u) : Projective X where factors f e _ := have he : Function.Surjective e := surjective_of_epi e - ⟨TypeCat.ofHom (fun x => (he (f x)).choose), by ext x; exact (he (f x)).choose_spec⟩ + ⟨↾ (fun x => (he (f x)).choose), by ext x; exact (he (f x)).choose_spec⟩ instance Type.enoughProjectives : EnoughProjectives (Type u) where presentation X := ⟨⟨X, 𝟙 X⟩⟩ diff --git a/Mathlib/CategoryTheory/Presentable/Type.lean b/Mathlib/CategoryTheory/Presentable/Type.lean index 759f66c40d26b2..6670baf04f5694 100644 --- a/Mathlib/CategoryTheory/Presentable/Type.lean +++ b/Mathlib/CategoryTheory/Presentable/Type.lean @@ -39,7 +39,7 @@ lemma isCardinalPresentable (hX : HasCardinalLT X κ) [Fact κ.IsRegular] : · dsimp at f choose j g hg using fun x ↦ Types.jointly_surjective_of_isColimit hc (f x) refine ⟨IsCardinalFiltered.max j hX, - TypeCat.ofHom (fun x ↦ F.map (IsCardinalFiltered.toMax j hX x) (g x)), ?_⟩ + ↾ (fun x ↦ F.map (IsCardinalFiltered.toMax j hX x) (g x)), ?_⟩ dsimp ext x dsimp at j g hg x ⊢ @@ -96,7 +96,7 @@ def functor : HasCardinalLT.Set X κ ⥤ Type u := @[simps] def cocone : Cocone (Set.functor X κ) where pt := X - ι.app _ := TypeCat.ofHom (Subtype.val) + ι.app _ := ↾ (Subtype.val) /-- Any type `X` is the (filtered) colimit of its subsets of cardinality `< κ` when `κ` is an infinite cardinal. (This colimit is `κ`-filtered when `κ` is diff --git a/Mathlib/CategoryTheory/ShrinkYoneda.lean b/Mathlib/CategoryTheory/ShrinkYoneda.lean index 326c54e93c49f4..960f26861b705b 100644 --- a/Mathlib/CategoryTheory/ShrinkYoneda.lean +++ b/Mathlib/CategoryTheory/ShrinkYoneda.lean @@ -40,7 +40,7 @@ obtained by shrinking `F.obj X` for all `X : C`. -/ noncomputable def shrink (F : C ⥤ Type w') [FunctorToTypes.Small.{w} F] : C ⥤ Type w where obj X := Shrink.{w} (F.obj X) - map f := TypeCat.ofHom (equivShrink.{w} _ ∘ F.map f ∘ (equivShrink.{w} _).symm) + map f := ↾ (equivShrink.{w} _ ∘ F.map f ∘ (equivShrink.{w} _).symm) /-- The natural transformation `shrink.{w} F ⟶ shrink.{w} G` induces by a natural transformation `τ : F ⟶ G` between `w`-small functors to types. -/ @@ -48,7 +48,7 @@ transformation `τ : F ⟶ G` between `w`-small functors to types. -/ noncomputable def shrinkMap {F G : C ⥤ Type w'} (τ : F ⟶ G) [FunctorToTypes.Small.{w} F] [FunctorToTypes.Small.{w} G] : shrink.{w} F ⟶ shrink.{w} G where - app X := TypeCat.ofHom (equivShrink.{w} _ ∘ τ.app X ∘ (equivShrink.{w} _).symm) + app X := ↾ (equivShrink.{w} _ ∘ τ.app X ∘ (equivShrink.{w} _).symm) /-- Shrinking `F` to `Type w` followed by universe lifting is the same as shrinking to `Type (max w w')`. -/ @@ -121,7 +121,7 @@ noncomputable def shrinkYonedaEquiv {X : C} {P : Cᵒᵖ ⥤ Type w} : (shrinkYoneda.{w}.obj X ⟶ P) ≃ P.obj (op X) where toFun τ := τ.app _ (equivShrink.{w} _ (𝟙 X)) invFun x := - { app Y := TypeCat.ofHom (fun f ↦ P.map ((equivShrink.{w} _).symm f).op x) + { app Y := ↾ (fun f ↦ P.map ((equivShrink.{w} _).symm f).op x) naturality Y Z g := by ext; simp [shrinkYoneda] } left_inv τ := by ext Y f diff --git a/Mathlib/CategoryTheory/Sites/Closed.lean b/Mathlib/CategoryTheory/Sites/Closed.lean index c9d1a1e82b16f7..067a5c59199912 100644 --- a/Mathlib/CategoryTheory/Sites/Closed.lean +++ b/Mathlib/CategoryTheory/Sites/Closed.lean @@ -154,7 +154,7 @@ subobject classifier for the category of presheaves. -/ @[simps] def Functor.sieves : Cᵒᵖ ⥤ Type max v u where obj X := Sieve X.unop - map f := TypeCat.ofHom fun S ↦ S.pullback f.unop + map f := ↾ fun S ↦ S.pullback f.unop /-- The presheaf sending each object to the set of `J`-closed sieves on it. This presheaf is a `J`-sheaf diff --git a/Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean b/Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean index d2a6c191d54d07..fc0db64e737913 100644 --- a/Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean +++ b/Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean @@ -87,7 +87,7 @@ theorem equalizerCondition_precomp_of_preservesPullback (P : Cᵒᵖ ⥤ D) (F : def mapToEqualizer (P : Cᵒᵖ ⥤ Type*) {W X B : C} (f : X ⟶ B) (g₁ g₂ : W ⟶ X) (w : g₁ ≫ f = g₂ ≫ f) : P.obj (op B) ⟶ { x : P.obj (op X) | P.map g₁.op x = P.map g₂.op x } := - TypeCat.ofHom fun t ↦ + ↾ fun t ↦ ⟨P.map f.op t, by simp only [Set.mem_setOf_eq, ← comp_apply, ← Functor.map_comp, ← op_comp, w]⟩ @[deprecated (since := "2025-11-23")] alias MapToEqualizer := mapToEqualizer diff --git a/Mathlib/CategoryTheory/Sites/DenseSubsite/Basic.lean b/Mathlib/CategoryTheory/Sites/DenseSubsite/Basic.lean index 1475d239a60767..bdbe22e2e55f93 100644 --- a/Mathlib/CategoryTheory/Sites/DenseSubsite/Basic.lean +++ b/Mathlib/CategoryTheory/Sites/DenseSubsite/Basic.lean @@ -221,7 +221,7 @@ theorem pushforwardFamily_compatible {X} (x : ℱ.obj (op X)) : Category.assoc, e] /-- (Implementation). The morphism `ℱ(X) ⟶ ℱ'(X)` given by gluing the `pushforwardFamily`. -/ -noncomputable def appHom (X : D) : ℱ.obj (op X) ⟶ ℱ'.obj.obj (op X) := TypeCat.ofHom fun x => +noncomputable def appHom (X : D) : ℱ.obj (op X) ⟶ ℱ'.obj.obj (op X) := ↾ fun x => ((isSheaf_iff_isSheaf_of_type _ _).1 ℱ'.property _ (G.is_cover_of_isCoverDense _ X)).amalgamate (pushforwardFamily α x) (pushforwardFamily_compatible α x) diff --git a/Mathlib/CategoryTheory/Sites/Descent/IsPrestack.lean b/Mathlib/CategoryTheory/Sites/Descent/IsPrestack.lean index beeba622d30435..f60a1bf82751cc 100644 --- a/Mathlib/CategoryTheory/Sites/Descent/IsPrestack.lean +++ b/Mathlib/CategoryTheory/Sites/Descent/IsPrestack.lean @@ -124,7 +124,7 @@ of morphisms $p^* M ⟶ p^* N$. -/ def presheafHom : (Over S)ᵒᵖ ⥤ Type v' where obj T := (F.map (.toLoc T.unop.hom.op)).toFunctor.obj M ⟶ (F.map (.toLoc T.unop.hom.op)).toFunctor.obj N - map {T₁ T₂} p := TypeCat.ofHom (fun f ↦ pullHom f p.unop.left T₂.unop.hom T₂.unop.hom) + map {T₁ T₂} p := ↾ (fun f ↦ pullHom f p.unop.left T₂.unop.hom T₂.unop.hom) /-- The bijection `(M ⟶ N) ≃ (F.presheafHom M N).obj (op (Over.mk (𝟙 S)))`. -/ @[simps! -isSimp] diff --git a/Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean b/Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean index 0cc0b86ca497e2..2ac02691b1169d 100644 --- a/Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean +++ b/Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean @@ -71,9 +71,9 @@ variable (P R) /-- Show that `FirstObj` is isomorphic to `FamilyOfElements`. -/ @[simps] def firstObjEqFamily : FirstObj P R ≅ (R.FamilyOfElements P) where - hom := TypeCat.ofHom fun t _ _ hf ↦ + hom := ↾ fun t _ _ hf ↦ Pi.π (fun f : Σ Y, { f : Y ⟶ X // R f } => P.obj (op f.1)) ⟨_, _, hf⟩ t - inv := Pi.lift fun f => TypeCat.ofHom (fun x => x _ f.2.2) + inv := Pi.lift fun f => ↾ (fun x => x _ f.2.2) instance : Inhabited (FirstObj P (⊥ : Presieve X)) := (firstObjEqFamily P _).toEquiv.inhabited diff --git a/Mathlib/CategoryTheory/Sites/GlobalSections.lean b/Mathlib/CategoryTheory/Sites/GlobalSections.lean index 9ad433ac51b191..96fdd981ea3b3f 100644 --- a/Mathlib/CategoryTheory/Sites/GlobalSections.lean +++ b/Mathlib/CategoryTheory/Sites/GlobalSections.lean @@ -192,7 +192,7 @@ lemma Sheaf.ΓObjEquivSections_naturality [HasWeakSheafify J (Type w)] (ΓObjEquivSections J G) ((Γ J _).map f x) = (Functor.sectionsFunctor _).map f.hom ((ΓObjEquivSections J F) x) := by dsimp [ΓObjEquivSections] - exact (congr_arg _ (ΓHomEquiv_naturality_right_symm (TypeCat.ofHom (uniqueElim x)) f)).trans + exact (congr_arg _ (ΓHomEquiv_naturality_right_symm (↾ (uniqueElim x)) f)).trans (Functor.sectionsEquivHom_naturality_symm _ _ _) lemma Sheaf.ΓObjEquivSections_naturality_symm [HasWeakSheafify J (Type w)] @@ -222,7 +222,7 @@ lemma Sheaf.ΓObjEquivHom_naturality [HasWeakSheafify J (Type w)] {F G : Sheaf J (Type w)} (f : F ⟶ G) (x : (Γ J (Type w)).obj F) : (ΓObjEquivHom J G X) ((Γ J (Type w)).map f x) = (ΓObjEquivHom J F X) x ≫ f := (constantSheafΓAdj J (Type w)).homEquiv_naturality_right_symm - (TypeCat.ofHom (uniqueElim x)) f + (↾ (uniqueElim x)) f lemma Sheaf.ΓObjEquivHom_naturality_symm [HasWeakSheafify J (Type w)] [HasGlobalSectionsFunctor J (Type w)] {X : Type w} [Unique X] diff --git a/Mathlib/CategoryTheory/Sites/IsSheafFor.lean b/Mathlib/CategoryTheory/Sites/IsSheafFor.lean index 4573627243f011..2740b6f8ceaba8 100644 --- a/Mathlib/CategoryTheory/Sites/IsSheafFor.lean +++ b/Mathlib/CategoryTheory/Sites/IsSheafFor.lean @@ -474,7 +474,7 @@ noncomputable def shrinkFunctorHomEquiv [LocallySmall.{w} C] {F : Cᵒᵖ ⥤ Ty rw! [shrinkYonedaObjObjEquiv_symm_comp] rfl⟩ invFun t := - { app X := TypeCat.ofHom fun f ↦ t.1 _ f.mem + { app X := ↾ fun f ↦ t.1 _ f.mem naturality Y Z g := by ext ⟨f, hf⟩ dsimp diff --git a/Mathlib/CategoryTheory/Sites/Preserves.lean b/Mathlib/CategoryTheory/Sites/Preserves.lean index 12278972147d57..1c8d303c4177d5 100644 --- a/Mathlib/CategoryTheory/Sites/Preserves.lean +++ b/Mathlib/CategoryTheory/Sites/Preserves.lean @@ -56,7 +56,7 @@ noncomputable def isTerminal_of_isSheafFor_empty_presieve : IsTerminal (F.obj (op I)) := by refine @IsTerminal.ofUnique _ _ _ fun Y ↦ ?_ choose t h using hF (by tauto) (by tauto) - exact ⟨⟨TypeCat.ofHom (fun _ ↦ t)⟩, fun a ↦ by ext; exact h.2 _ (by tauto)⟩ + exact ⟨⟨↾ (fun _ ↦ t)⟩, fun a ↦ by ext; exact h.2 _ (by tauto)⟩ include hF in /-- diff --git a/Mathlib/CategoryTheory/Sites/Sheaf.lean b/Mathlib/CategoryTheory/Sites/Sheaf.lean index 86dcd725acb774..acff897bc321dd 100644 --- a/Mathlib/CategoryTheory/Sites/Sheaf.lean +++ b/Mathlib/CategoryTheory/Sites/Sheaf.lean @@ -395,7 +395,7 @@ theorem isSheaf_iff_isSheaf_of_type (P : Cᵒᵖ ⥤ Type w) : refine Presieve.isSheaf_iso J ?_ (hP (PUnit)) exact Functor.isoWhiskerLeft _ Coyoneda.punitIso ≪≫ P.rightUnitor · intro hP X Y S hS z hz - refine ⟨TypeCat.ofHom fun x => (hP S hS).amalgamate (fun Z f hf ↦ + refine ⟨↾ fun x => (hP S hS).amalgamate (fun Z f hf ↦ (ConcreteCategory.hom (z f hf)) x) ?_, ?_, ?_⟩ · intro Y₁ Y₂ Z g₁ g₂ f₁ f₂ hf₁ hf₂ h exact (ConcreteCategory.congr_hom (hz g₁ g₂ hf₁ hf₂ h)) x diff --git a/Mathlib/CategoryTheory/Sites/SheafHom.lean b/Mathlib/CategoryTheory/Sites/SheafHom.lean index 347bcdcfb820f9..54a674a5061051 100644 --- a/Mathlib/CategoryTheory/Sites/SheafHom.lean +++ b/Mathlib/CategoryTheory/Sites/SheafHom.lean @@ -45,7 +45,7 @@ to the type of morphisms between the "restrictions" of `F` and `G` to the catego @[simps! obj] def presheafHom : Cᵒᵖ ⥤ Type _ where obj X := (Over.forget X.unop).op ⋙ F ⟶ (Over.forget X.unop).op ⋙ G - map f := TypeCat.ofHom (Functor.whiskerLeft (Over.map f.unop).op) + map f := ↾ (Functor.whiskerLeft (Over.map f.unop).op) map_id := by rintro ⟨X⟩ ext φ ⟨Y⟩ @@ -216,7 +216,7 @@ lemma Presheaf.IsSheaf.hom (hG : Presheaf.IsSheaf J G) : (see `sheafHom'Iso`), but has better definitional properties. -/ def sheafHom' (F G : Sheaf J A) : Cᵒᵖ ⥤ Type _ where obj X := ((J.overPullback A X.unop).obj F ⟶ (J.overPullback A X.unop).obj G) - map f := TypeCat.ofHom ((J.overMapPullback A f.unop).map) + map f := ↾ ((J.overMapPullback A f.unop).map) map_id X := by ext φ : 4 exact ConcreteCategory.congr_hom ((presheafHom F.1 G.1).map_id X) φ.1 diff --git a/Mathlib/CategoryTheory/Sites/Sieves.lean b/Mathlib/CategoryTheory/Sites/Sieves.lean index 71ed64984d6056..611c71493890f7 100644 --- a/Mathlib/CategoryTheory/Sites/Sieves.lean +++ b/Mathlib/CategoryTheory/Sites/Sieves.lean @@ -1191,25 +1191,25 @@ end Functor @[simps obj map] def functor (S : Sieve X) : Cᵒᵖ ⥤ Type v₁ where obj Y := { g : Y.unop ⟶ X // S g } - map f := TypeCat.ofHom fun g ↦ ⟨f.unop ≫ g.1, downward_closed _ g.2 _⟩ + map f := ↾ fun g ↦ ⟨f.unop ≫ g.1, downward_closed _ g.2 _⟩ /-- If a sieve S is contained in a sieve T, then we have a morphism of presheaves on their induced presheaves. -/ @[simps] def natTransOfLe {S T : Sieve X} (h : S ≤ T) : S.functor ⟶ T.functor where - app _ := TypeCat.ofHom fun f ↦ ⟨f.1, h _ f.2⟩ + app _ := ↾ fun f ↦ ⟨f.1, h _ f.2⟩ /-- The natural inclusion from the functor induced by a sieve to the yoneda embedding. -/ @[simps] def functorInclusion (S : Sieve X) : S.functor ⟶ yoneda.obj X where - app _ := TypeCat.ofHom (fun f ↦ f.1) + app _ := ↾ (fun f ↦ f.1) /-- Any component `f : Y ⟶ X` of the sieve `S` induces a natural transformation from `yoneda.obj Y` to the presheaf induced by `S`. -/ @[simps] def toFunctor (S : Sieve X) {Y : C} (f : Y ⟶ X) (hf : S f) : yoneda.obj Y ⟶ S.functor where - app Z := TypeCat.ofHom fun g ↦ ⟨g ≫ f, S.downward_closed hf g⟩ + app Z := ↾ fun g ↦ ⟨g ≫ f, S.downward_closed hf g⟩ theorem natTransOfLe_comm {S T : Sieve X} (h : S ≤ T) : natTransOfLe h ≫ functorInclusion _ = functorInclusion _ := @@ -1245,7 +1245,7 @@ theorem sieveOfSubfunctor_functorInclusion : sieveOfSubfunctor S.functorInclusio exact ⟨⟨_, hf⟩, rfl⟩ instance functorInclusion_top_isIso : IsIso (⊤ : Sieve X).functorInclusion := - ⟨⟨{ app := fun _ => TypeCat.ofHom fun a => ⟨a, ⟨⟩⟩ }, rfl, rfl⟩⟩ + ⟨⟨{ app := fun _ => ↾ fun a => ⟨a, ⟨⟩⟩ }, rfl, rfl⟩⟩ /-- A variant of `Sieve.functor` with universe lifting. -/ abbrev uliftFunctor (S : Sieve X) : Cᵒᵖ ⥤ Type (max w v₁) := @@ -1255,7 +1255,7 @@ abbrev uliftFunctor (S : Sieve X) : Cᵒᵖ ⥤ Type (max w v₁) := @[simps] def uliftNatTransOfLe {S T : Sieve X} (h : S ≤ T) : Sieve.uliftFunctor.{w} S ⟶ Sieve.uliftFunctor.{w} T where - app _ := TypeCat.ofHom fun f ↦ ⟨f.down.1, h _ f.down.2⟩ + app _ := ↾ fun f ↦ ⟨f.down.1, h _ f.down.2⟩ /-- A variant of `Sieve.functorInclusion` with universe lifting. -/ @[simps! app] @@ -1267,7 +1267,7 @@ def uliftFunctorInclusion (S : Sieve X) : @[simps] def toUliftFunctor (S : Sieve X) {Y : C} (f : Y ⟶ X) (hf : S f) : uliftYoneda.obj.{w} Y ⟶ Sieve.uliftFunctor.{w} S where - app Z := TypeCat.ofHom fun g ↦ ⟨g.down ≫ f, S.downward_closed hf g.down⟩ + app Z := ↾ fun g ↦ ⟨g.down ≫ f, S.downward_closed hf g.down⟩ theorem uliftNatTransOfLe_comm {S T : Sieve X} (h : S ≤ T) : uliftNatTransOfLe.{w} h ≫ uliftFunctorInclusion.{w} _ = uliftFunctorInclusion.{w} _ := @@ -1297,7 +1297,7 @@ theorem sieveOfUliftSubfunctor_uliftFunctorInclusion {S : Sieve X} : cat_disch instance uliftFunctorInclusion_top_isIso : IsIso (Sieve.uliftFunctorInclusion.{w} (⊤ : Sieve X)) := - ⟨⟨{ app := fun _ ↦ TypeCat.ofHom fun a ↦ ⟨a.down, ⟨⟩⟩ }, rfl, rfl⟩⟩ + ⟨⟨{ app := fun _ ↦ ↾ fun a ↦ ⟨a.down, ⟨⟩⟩ }, rfl, rfl⟩⟩ lemma ofArrows_eq_pullback_of_isPullback {ι : Type*} {S : C} {X : ι → C} (f : (i : ι) → X i ⟶ S) {Y : C} {g : Y ⟶ S} {P : ι → C} {p₁ : (i : ι) → P i ⟶ Y} {p₂ : (i : ι) → P i ⟶ X i} diff --git a/Mathlib/CategoryTheory/Sites/Subcanonical.lean b/Mathlib/CategoryTheory/Sites/Subcanonical.lean index c953c6cd0d5afe..f0febd401aebd3 100644 --- a/Mathlib/CategoryTheory/Sites/Subcanonical.lean +++ b/Mathlib/CategoryTheory/Sites/Subcanonical.lean @@ -295,7 +295,7 @@ noncomputable def isColimitCofanMkYoneda {ι : Type*} (X : ι → C) {c : Cofan exact Subsingleton.elim _ _ refine mkCofanColimit _ (fun s ↦ ⟨?_⟩) (fun s j ↦ ?_) fun s m hm ↦ ?_ · refine (s.pt.2.isSheafFor _ H).extend ?_ - refine ⟨fun Y ↦ TypeCat.ofHom fun g ↦ ((s.inj (Sieve.ofArrows.i g.2)).hom.app Y) + refine ⟨fun Y ↦ ↾ fun g ↦ ((s.inj (Sieve.ofArrows.i g.2)).hom.app Y) (Sieve.ofArrows.h g.2), ?_⟩ intro ⟨Y⟩ ⟨Z⟩ ⟨(g : Z ⟶ Y)⟩ ext u diff --git a/Mathlib/CategoryTheory/Sites/Subsheaf.lean b/Mathlib/CategoryTheory/Sites/Subsheaf.lean index c8fbde758b8f88..34d87b51bade1e 100644 --- a/Mathlib/CategoryTheory/Sites/Subsheaf.lean +++ b/Mathlib/CategoryTheory/Sites/Subsheaf.lean @@ -151,7 +151,7 @@ alias Subpresheaf.sheafify_sheafify := Subfunctor.sheafify_sheafify /-- The lift of a presheaf morphism onto the sheafification subpresheaf. -/ noncomputable def Subfunctor.sheafifyLift (f : G.toFunctor ⟶ F') (h : Presieve.IsSheaf J F') : (G.sheafify J).toFunctor ⟶ F' where - app _ := TypeCat.ofHom fun s ↦ (h (G.sieveOfSection s.1) s.prop).amalgamate + app _ := ↾ fun s ↦ (h (G.sieveOfSection s.1) s.prop).amalgamate (_) ((G.family_of_elements_compatible s.1).map f) naturality := by intro U V i diff --git a/Mathlib/CategoryTheory/Sites/Types.lean b/Mathlib/CategoryTheory/Sites/Types.lean index 09ce397959cf26..7bb72d43261612 100644 --- a/Mathlib/CategoryTheory/Sites/Types.lean +++ b/Mathlib/CategoryTheory/Sites/Types.lean @@ -27,7 +27,7 @@ namespace CategoryTheory /-- A Grothendieck topology associated to the category of all types. A sieve is a covering iff it is jointly surjective. -/ def typesGrothendieckTopology : GrothendieckTopology (Type u) where - sieves α := {S | ∀ x : α, S <| TypeCat.ofHom (fun _ : PUnit => x)} + sieves α := {S | ∀ x : α, S <| ↾ (fun _ : PUnit => x)} top_mem' _ _ := trivial pullback_stable' _ _ _ f hs x := hs (f x) transitive' _ _ hs _ hr x := hr (hs x) PUnit.unit @@ -47,16 +47,16 @@ def discretePresieve (α : Type u) : Presieve α := theorem generate_discretePresieve_mem (α : Type u) : Sieve.generate (discretePresieve α) ∈ typesGrothendieckTopology α := - fun x => ⟨PUnit, 𝟙 _, TypeCat.ofHom (fun _ => x), + fun x => ⟨PUnit, 𝟙 _, ↾ (fun _ => x), ⟨PUnit.unit, fun _ => Subsingleton.elim _ _⟩, rfl⟩ /-- The sheaf condition for `yoneda'`. -/ theorem Presieve.isSheaf_yoneda' {α : Type u} : Presieve.IsSheaf typesGrothendieckTopology (yoneda.obj α) := fun β _ hs x hx => - ⟨TypeCat.ofHom (fun y => (x _ (hs y)).hom PUnit.unit) , fun γ f h => + ⟨↾ (fun y => (x _ (hs y)).hom PUnit.unit) , fun γ f h => ConcreteCategory.hom_ext _ _ fun z => by - convert ConcreteCategory.congr_hom (hx (𝟙 _) (TypeCat.ofHom (fun _ => z)) + convert ConcreteCategory.congr_hom (hx (𝟙 _) (↾ (fun _ => z)) (hs <| f z) h rfl) PUnit.unit using 1, fun f hf => ConcreteCategory.hom_ext _ _ fun y => by convert ConcreteCategory.congr_hom (hf _ (hs y)) PUnit.unit⟩ @@ -83,7 +83,7 @@ open Opposite a map `P(α) → (α → P(*))` for all type `α`. -/ def eval (P : Type uᵒᵖ ⥤ Type u) (α : Type u) (s : P.obj (op α)) : α ⟶ P.obj (op PUnit) := - TypeCat.ofHom (fun x ↦ P.map (TypeCat.ofHom (fun _ => x)).op s) + ↾ (fun x ↦ P.map (↾ (fun _ => x)).op s) open Presieve @@ -93,7 +93,7 @@ noncomputable def typesGlue (S : Type uᵒᵖ ⥤ Type u) (hs : IsSheaf typesGrothendieckTopology S) (α : Type u) (f : α → S.obj (op PUnit)) : S.obj (op α) := (hs.isSheafFor _ (generate_discretePresieve_mem α)).amalgamate - (fun _ g hg => S.map (TypeCat.ofHom (fun _ => PUnit.unit)).op <| f <| g <| Classical.choose hg) + (fun _ g hg => S.map (↾ (fun _ => PUnit.unit)).op <| f <| g <| Classical.choose hg) fun β γ δ g₁ g₂ f₁ f₂ hf₁ hf₂ h => (hs.isSheafFor _ (generate_discretePresieve_mem δ)).isSeparatedFor.ext fun ε g ⟨x, _⟩ => by have : f₁ (Classical.choose hf₁) = f₂ (Classical.choose hf₂) := @@ -155,7 +155,7 @@ noncomputable def equivYoneda' (S : Sheaf typesGrothendieckTopology (Type u)) : theorem eval_app (S₁ S₂ : Sheaf typesGrothendieckTopology (Type u)) (f : S₁ ⟶ S₂) (α : Type u) (s : S₁.1.obj (op α)) (x : α) : eval S₂.1 α (f.hom.app (op α) s) x = f.hom.app (op PUnit) (eval S₁.1 α s x) := - (ConcreteCategory.congr_hom (f.hom.naturality (TypeCat.ofHom (fun _ => x)).op) s).symm + (ConcreteCategory.congr_hom (f.hom.naturality (↾ (fun _ => x)).op) s).symm set_option backward.isDefEq.respectTransparency false in /-- `yoneda'` induces an equivalence of categories between `Type u` and @@ -166,8 +166,8 @@ noncomputable def typeEquiv : Type u ≌ Sheaf typesGrothendieckTopology (Type u inverse := sheafToPresheaf _ _ ⋙ (evaluation _ _).obj (op (PUnit)) unitIso := dsimp% NatIso.ofComponents (fun _α => -- α ≅ PUnit ⟶ α - { hom := TypeCat.ofHom (fun x => TypeCat.ofHom (fun _ => x)) - inv := TypeCat.ofHom (fun f => f.hom PUnit.unit) }) + { hom := ↾ (fun x => ↾ (fun _ => x)) + inv := ↾ (fun f => f.hom PUnit.unit) }) fun _ => rfl counitIso := Iso.symm <| NatIso.ofComponents (fun S => equivYoneda' S) (fun {S₁ S₂} f => by @@ -192,12 +192,12 @@ theorem typesGrothendieckTopology_eq_canonical : ext S refine ⟨fun hs x => ?_, fun hs β f => Presieve.isSheaf_yoneda' _ fun y => hs (f y)⟩ by_contra hsx - have : TypeCat.ofHom (fun _ => ULift.up true) = TypeCat.ofHom (fun _ => ULift.up false) := - (hs PUnit (TypeCat.ofHom (fun _ => x))).isSeparatedFor.ext + have : ↾ (fun _ => ULift.up true) = ↾ (fun _ => ULift.up false) := + (hs PUnit (↾ (fun _ => x))).isSeparatedFor.ext fun β f hf => by dsimp ext y - exact hsx.elim <| S.2 hf (TypeCat.ofHom (fun _ => y)) + exact hsx.elim <| S.2 hf (↾ (fun _ => y)) simp [ConcreteCategory.hom_ext_iff] at this diff --git a/Mathlib/CategoryTheory/SmallObject/TransfiniteCompositionLifting.lean b/Mathlib/CategoryTheory/SmallObject/TransfiniteCompositionLifting.lean index 7aca82d3a8016f..56005851bed2b3 100644 --- a/Mathlib/CategoryTheory/SmallObject/TransfiniteCompositionLifting.lean +++ b/Mathlib/CategoryTheory/SmallObject/TransfiniteCompositionLifting.lean @@ -141,7 +141,7 @@ end SqStruct @[simps] def sqFunctor : Jᵒᵖ ⥤ Type _ where obj j := SqStruct c p f g j.unop - map α := TypeCat.ofHom (fun sq' ↦ sq'.map α.unop) + map α := ↾ (fun sq' ↦ sq'.map α.unop) variable [F.IsWellOrderContinuous] diff --git a/Mathlib/CategoryTheory/Subfunctor/Basic.lean b/Mathlib/CategoryTheory/Subfunctor/Basic.lean index 7c06f5ff43474a..665ed955cd113f 100644 --- a/Mathlib/CategoryTheory/Subfunctor/Basic.lean +++ b/Mathlib/CategoryTheory/Subfunctor/Basic.lean @@ -142,14 +142,14 @@ instance : Nonempty (Subfunctor F) := @[simps obj map] def toFunctor : C ⥤ Type w where obj U := G.obj U - map i := TypeCat.ofHom fun x => ⟨F.map i x, G.map i x.prop⟩ + map i := ↾ fun x => ⟨F.map i x, G.map i x.prop⟩ instance {U} : CoeHead (G.toFunctor.obj U) (F.obj U) where coe := Subtype.val /-- The inclusion of a subfunctor to the original functor. -/ @[simps] -def ι : G.toFunctor ⟶ F where app _ := TypeCat.ofHom (fun x ↦ x) +def ι : G.toFunctor ⟶ F where app _ := ↾ (fun x ↦ x) instance : Mono G.ι := ⟨@fun _ _ _ e => @@ -158,7 +158,7 @@ instance : Mono G.ι := /-- The inclusion of a subfunctor to a larger subfunctor -/ @[simps] def homOfLe {G G' : Subfunctor F} (h : G ≤ G') : G.toFunctor ⟶ G'.toFunctor where - app U := TypeCat.ofHom fun x ↦ ⟨x, h U x.prop⟩ + app U := ↾ fun x ↦ ⟨x, h U x.prop⟩ instance {G G' : Subfunctor F} (h : G ≤ G') : Mono (Subfunctor.homOfLe h) := ⟨fun _ _ e => NatTrans.ext <| funext fun U => hom_ext _ _ fun x => by diff --git a/Mathlib/CategoryTheory/Subfunctor/Image.lean b/Mathlib/CategoryTheory/Subfunctor/Image.lean index 017937a912baf1..ae607400649319 100644 --- a/Mathlib/CategoryTheory/Subfunctor/Image.lean +++ b/Mathlib/CategoryTheory/Subfunctor/Image.lean @@ -54,7 +54,7 @@ variable (f : F' ⟶ F) {G : Subfunctor F} (hf : range f ≤ G) /-- If the image of a morphism falls in a subfunctor, then the morphism factors through it. -/ @[simps! app] def lift : F' ⟶ G.toFunctor where - app U := TypeCat.ofHom fun x => ⟨f.app U x, hf U (by simp)⟩ + app U := ↾ fun x => ⟨f.app U x, hf U (by simp)⟩ naturality _ _ g := by ext x simpa [Subtype.ext_iff, -NatTrans.naturality_apply] using NatTrans.naturality_apply f g x diff --git a/Mathlib/CategoryTheory/Subobject/Lattice.lean b/Mathlib/CategoryTheory/Subobject/Lattice.lean index b541141c2ad2dd..f6a3e35a616dea 100644 --- a/Mathlib/CategoryTheory/Subobject/Lattice.lean +++ b/Mathlib/CategoryTheory/Subobject/Lattice.lean @@ -333,7 +333,7 @@ variable (C) @[simps] def functor [HasPullbacks C] : Cᵒᵖ ⥤ Type max u₁ v₁ where obj X := Subobject X.unop - map f := TypeCat.ofHom (pullback f.unop).obj + map f := ↾ (pullback f.unop).obj map_id _ := by ext : 3; simp [pullback_id] map_comp _ _ := by ext : 3; simp [pullback_comp] diff --git a/Mathlib/CategoryTheory/Subobject/Presheaf.lean b/Mathlib/CategoryTheory/Subobject/Presheaf.lean index 29bf0938e5a2ce..f317923a060a36 100644 --- a/Mathlib/CategoryTheory/Subobject/Presheaf.lean +++ b/Mathlib/CategoryTheory/Subobject/Presheaf.lean @@ -48,7 +48,7 @@ subobject of `Y` to its pullback along `f`. -/ @[simps] noncomputable def presheaf : Cᵒᵖ ⥤ Type max u v where obj X := Subobject X.unop - map f := TypeCat.ofHom (pullback f.unop).obj + map f := ↾ (pullback f.unop).obj map_id _ := by ext : 3; simp [pullback_id] map_comp _ _ := by ext : 3; simp [pullback_comp] diff --git a/Mathlib/CategoryTheory/Subobject/Types.lean b/Mathlib/CategoryTheory/Subobject/Types.lean index a0d8fcae473592..1b4c1f42759e03 100644 --- a/Mathlib/CategoryTheory/Subobject/Types.lean +++ b/Mathlib/CategoryTheory/Subobject/Types.lean @@ -32,7 +32,7 @@ open CategoryTheory ConcreteCategory open CategoryTheory.Subobject -theorem subtype_val_mono {α : Type u} (s : Set α) : Mono (TypeCat.ofHom (Subtype.val : s → α)) := +theorem subtype_val_mono {α : Type u} (s : Set α) : Mono (↾ (Subtype.val : s → α)) := (mono_iff_injective _).mpr Subtype.val_injective attribute [local instance] subtype_val_mono @@ -49,8 +49,8 @@ noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ S rintro a ⟨x, rfl⟩ exact ⟨t.hom.1 x, congr_hom t.hom.w x⟩) } inverse := - { obj := fun s => MonoOver.mk <| TypeCat.ofHom (Subtype.val : s → α) - map := fun {s t} b => MonoOver.homMk (TypeCat.ofHom + { obj := fun s => MonoOver.mk <| ↾ (Subtype.val : s → α) + map := fun {s t} b => MonoOver.homMk (↾ fun w => ⟨w.1, Set.mem_of_mem_of_subset w.2 b.le⟩) } unitIso := NatIso.ofComponents fun f => diff --git a/Mathlib/CategoryTheory/Topos/Sheaf.lean b/Mathlib/CategoryTheory/Topos/Sheaf.lean index d443a4e16769c7..89390117c9f43a 100644 --- a/Mathlib/CategoryTheory/Topos/Sheaf.lean +++ b/Mathlib/CategoryTheory/Topos/Sheaf.lean @@ -55,7 +55,7 @@ variable (C) in map returning `⊤ : Sieve X`. -/ @[simps] def Presheaf.truth : (Functor.const _).obj PUnit ⟶ Functor.sieves C where - app X := TypeCat.ofHom fun _ ↦ (⊤ : Sieve X.unop) + app X := ↾ fun _ ↦ (⊤ : Sieve X.unop) variable {F G : Cᵒᵖ ⥤ Type (max u v)} @@ -67,7 +67,7 @@ to the (closed) sieve on X where `f : Y → X` is in the sieve iff -/ @[simps app] def Presheaf.χ (m : F ⟶ G) : G ⟶ Functor.sieves C where - app X := TypeCat.ofHom fun x ↦ ⟨fun Y f => ∃ a, G.map f.op x = m.app (.op Y) a, by + app X := ↾ fun x ↦ ⟨fun Y f => ∃ a, G.map f.op x = m.app (.op Y) a, by intro Y Z f ⟨a, ha⟩ g use F.map g.op a simp [ha, NatTrans.naturality_apply]⟩ diff --git a/Mathlib/CategoryTheory/Types/Basic.lean b/Mathlib/CategoryTheory/Types/Basic.lean index 729b37e39ca156..fc715a47b7a6d1 100644 --- a/Mathlib/CategoryTheory/Types/Basic.lean +++ b/Mathlib/CategoryTheory/Types/Basic.lean @@ -28,7 +28,7 @@ a `FunLike` instance on the latter (which would give two non-reducibly defeq coe morphisms in `Type` to functions), and the outer nesting `TypeCat.Hom` gives a layer of separation between morphisms and `FC`, as is done for all concrete categories in mathlib. -To promote a function to a morphism in this category, we provide the abbreviation `TypeCat.ofHom f`, +To promote a function to a morphism in this category, we provide the abbreviation `↾ f`, as well as a corresponding notation `↾ f`. (Entered as `\upr `.) ## Main definitions @@ -136,7 +136,7 @@ abbrev ofHom {X Y : Type u} (f : X → Y) : X ⟶ Y := ConcreteCategory.ofHom (Fun.mk f) @[inherit_doc] -scoped notation "↾" f:200 => TypeCat.ofHom f +notation "↾" f:200 => TypeCat.ofHom f /-- Use the `ConcreteCategory.hom` projection for `@[simps]` lemmas. -/ def Hom.Simps.hom (X Y : Type u) (f : X ⟶ Y) := @@ -162,7 +162,7 @@ lemma ofHom_hom {X Y : Type u} (f : X ⟶ Y) : ofHom (Hom.hom f) = f := rfl @[simp] lemma ofHom_apply {X Y : Type u} (f : X → Y) (x : X) : - TypeCat.ofHom f x = f x := + (↾ f) x = f x := rfl /-- `TypeCat.Hom.hom` bundled as an `Equiv`. -/ @@ -208,7 +208,7 @@ lemma types_congr_hom {X Y : Type u} {f g : X ⟶ Y} (h : f = g) (x : X) : f x = @[deprecated (since := "2026-02-09")] alias hom_inv_id_apply := Iso.hom_inv_id_apply @[deprecated (since := "2026-02-09")] alias inv_hom_id_apply := Iso.inv_hom_id_apply -@[deprecated (since := "2026-02-09")] alias asHom := TypeCat.ofHom +@[deprecated (since := "2026-02-09")] alias asHom := ofHom namespace Functor @@ -237,7 +237,7 @@ variable (J) @[simps] def sectionsFunctor : (J ⥤ Type w) ⥤ Type max u w where obj F := F.sections - map {F G} φ := TypeCat.ofHom fun x ↦ ⟨fun j => φ.app j (x.1 j), fun {j j'} f => + map {F G} φ := ↾ fun x ↦ ⟨fun j => φ.app j (x.1 j), fun {j j'} f => by simp [← NatTrans.naturality_apply, x.2 f]⟩ end Functor diff --git a/Mathlib/CategoryTheory/Types/Set.lean b/Mathlib/CategoryTheory/Types/Set.lean index 66c77762d0d1e9..e8aba32ce46312 100644 --- a/Mathlib/CategoryTheory/Types/Set.lean +++ b/Mathlib/CategoryTheory/Types/Set.lean @@ -30,6 +30,6 @@ to its underlying type. -/ @[simps obj map] def functorToTypes {X : Type u} : Set X ⥤ Type u where obj S := S - map {S T} f := TypeCat.ofHom fun ⟨x, hx⟩ ↦ ⟨x, leOfHom f hx⟩ + map {S T} f := ↾ fun ⟨x, hx⟩ ↦ ⟨x, leOfHom f hx⟩ end Set diff --git a/Mathlib/CategoryTheory/Yoneda.lean b/Mathlib/CategoryTheory/Yoneda.lean index a5895464422dc4..860cbafe48136d 100644 --- a/Mathlib/CategoryTheory/Yoneda.lean +++ b/Mathlib/CategoryTheory/Yoneda.lean @@ -44,9 +44,9 @@ variable {C : Type u₁} [Category.{v₁} C] def yoneda : C ⥤ Cᵒᵖ ⥤ Type v₁ where obj X := { obj Y := (unop Y) ⟶ X - map f := TypeCat.ofHom fun g ↦ f.unop ≫ g } + map f := ↾ fun g ↦ f.unop ≫ g } map f := - { app _ := TypeCat.ofHom fun g ↦ g ≫ f } + { app _ := ↾ fun g ↦ g ≫ f } /-- Unification hint for `(yoneda.obj X).obj (op Y) = Y ⟶ X`. -/ unif_hint yoneda_obj_obj_eq_hom (X X' Y Y' : C) where @@ -167,8 +167,8 @@ def ext (X Y : C) (p : ∀ {Z : C}, (Z ⟶ X) → (Z ⟶ Y)) (n : ∀ {Z Z' : C} (f : Z' ⟶ Z) (g : Z ⟶ X), p (f ≫ g) = f ≫ p g) : X ≅ Y := fullyFaithful.preimageIso (NatIso.ofComponents fun Z => - { hom := TypeCat.ofHom p - inv := TypeCat.ofHom q }) + { hom := ↾ p + inv := ↾ q }) /-- If `yoneda.map f` is an isomorphism, so was `f`. -/ @@ -233,8 +233,8 @@ def ext (X Y : C) (p : ∀ {Z : C}, (X ⟶ Z) → (Y ⟶ Z)) (n : ∀ {Z Z' : C} (f : Y ⟶ Z) (g : Z ⟶ Z'), q (f ≫ g) = q f ≫ g) : X ≅ Y := fullyFaithful.preimageIso (NatIso.ofComponents (fun Z => - { hom := TypeCat.ofHom q - inv := TypeCat.ofHom p })) |>.unop + { hom := ↾ q + inv := ↾ p })) |>.unop /-- If `coyoneda.map f` is an isomorphism, so was `f`. -/ @@ -244,8 +244,8 @@ theorem isIso {X Y : Cᵒᵖ} (f : X ⟶ Y) [IsIso (coyoneda.map f)] : IsIso f : /-- The identity functor on `Type` is isomorphic to the coyoneda functor coming from `PUnit`. -/ def punitIso : coyoneda.obj (Opposite.op PUnit) ≅ 𝟭 (Type v₁) := NatIso.ofComponents fun X => - { hom := TypeCat.ofHom fun f => f.hom ⟨⟩ - inv := TypeCat.ofHom fun x => TypeCat.ofHom fun _ => x } + { hom := ↾ fun f => f.hom ⟨⟩ + inv := ↾ fun x => ↾ fun _ => x } /-- Taking the `unop` of morphisms is a natural isomorphism. -/ @[simps! inv_app hom_app] @@ -721,7 +721,7 @@ and elements of `F.obj X`, without any universe switching. -/ def yonedaEquiv {X : C} {F : Cᵒᵖ ⥤ Type v₁} : (yoneda.obj X ⟶ F) ≃ F.obj (op X) where toFun η := η.app (op X) (𝟙 X) - invFun ξ := { app _ := TypeCat.ofHom fun f ↦ F.map f.op ξ } + invFun ξ := { app _ := ↾ fun f ↦ F.map f.op ξ } left_inv := by intro η ext Y f @@ -734,7 +734,7 @@ theorem yonedaEquiv_apply {X : C} {F : Cᵒᵖ ⥤ Type v₁} (f : yoneda.obj X @[simp] theorem yonedaEquiv_symm_app {X : C} {F : Cᵒᵖ ⥤ Type v₁} (x : F.obj (op X)) (Y : Cᵒᵖ) : - (yonedaEquiv.symm x).app Y = TypeCat.ofHom fun f ↦ F.map f.op x := + (yonedaEquiv.symm x).app Y = ↾ fun f ↦ F.map f.op x := rfl theorem yonedaEquiv_symm_app_apply {X : C} {F : Cᵒᵖ ⥤ Type v₁} (x : F.obj (op X)) (Y : Cᵒᵖ) @@ -824,7 +824,7 @@ lemma yonedaPairingExt {X : Cᵒᵖ × (Cᵒᵖ ⥤ Type v₁)} {x y : (yonedaPa @[simp] theorem yonedaPairing_map (P Q : Cᵒᵖ × (Cᵒᵖ ⥤ Type v₁)) (α : P ⟶ Q) : - (yonedaPairing C).map α = TypeCat.ofHom fun β ↦ yoneda.map α.1.unop ≫ β ≫ α.2 := + (yonedaPairing C).map α = ↾ fun β ↦ yoneda.map α.1.unop ≫ β ≫ α.2 := rfl set_option backward.isDefEq.respectTransparency false in @@ -909,7 +909,7 @@ auxiliary universe `w`. -/ def uliftYonedaEquiv {X : C} {F : Cᵒᵖ ⥤ Type (max w v₁)} : (uliftYoneda.{w}.obj X ⟶ F) ≃ F.obj (op X) where toFun τ := τ.app (op X) (ULift.up (𝟙 _)) - invFun x := { app Y := TypeCat.ofHom fun y ↦ F.map y.down.op x } + invFun x := { app Y := ↾ fun y ↦ F.map y.down.op x } left_inv τ := by ext ⟨Y⟩ ⟨y⟩ simp [← NatTrans.naturality_apply] @@ -989,7 +989,7 @@ and elements of `F.obj X.unop`, without any universe switching. -/ def coyonedaEquiv {X : C} {F : C ⥤ Type v₁} : (coyoneda.obj (op X) ⟶ F) ≃ F.obj X where toFun η := η.app X (𝟙 X) - invFun ξ := { app _ := TypeCat.ofHom fun x ↦ F.map x ξ } + invFun ξ := { app _ := ↾ fun x ↦ F.map x ξ } left_inv := fun η ↦ by ext Y (x : X ⟶ Y) simp [← NatTrans.naturality_apply] @@ -1142,7 +1142,7 @@ auxiliary universe `w`. -/ def uliftCoyonedaEquiv {X : Cᵒᵖ} {F : C ⥤ Type (max w v₁)} : (uliftCoyoneda.{w}.obj X ⟶ F) ≃ F.obj X.unop where toFun τ := τ.app X.unop (ULift.up (𝟙 _)) - invFun x := { app Y := TypeCat.ofHom fun y ↦ F.map y.down x } + invFun x := { app Y := ↾ fun y ↦ F.map y.down x } left_inv τ := by ext Y ⟨x⟩ simp [← comp_apply, ← τ.naturality] @@ -1214,7 +1214,7 @@ variable {D : Type*} [Category.{v₁} D] (F : C ⥤ D) /-- The natural transformation `yoneda.obj X ⟶ F.op ⋙ yoneda.obj (F.obj X)` when `F : C ⥤ D` and `X : C`. -/ def yonedaMap (X : C) : yoneda.obj X ⟶ F.op ⋙ yoneda.obj (F.obj X) where - app _ := TypeCat.ofHom fun f ↦ F.map f + app _ := ↾ fun f ↦ F.map f @[simp] lemma yonedaMap_app_apply {Y : C} {X : Cᵒᵖ} (f : X.unop ⟶ Y) : @@ -1231,7 +1231,7 @@ variable {D : Type u₂} [Category.{v₂} D] (F : C ⥤ D) when `F : C ⥤ D` and `X : C`. -/ def uliftYonedaMap (X : C) : uliftYoneda.{max w v₂}.obj X ⟶ F.op ⋙ uliftYoneda.{max w v₁}.obj (F.obj X) where - app _ := TypeCat.ofHom fun f ↦ ULift.up (F.map (ULift.down f)) + app _ := ↾ fun f ↦ ULift.up (F.map (ULift.down f)) @[simp] lemma uliftYonedaMap_app_apply {Y : C} {X : Cᵒᵖ} (f : X.unop ⟶ Y) : @@ -1250,7 +1250,7 @@ functor. -/ def Functor.sectionsEquivHom (F : C ⥤ Type u₂) (X : Type u₂) [Unique X] : F.sections ≃ ((const _).obj X ⟶ F) where toFun s := - { app j := TypeCat.ofHom fun _ ↦ s.1 j + { app j := ↾ fun _ ↦ s.1 j naturality _ _ _ := by ext x; simp } invFun τ := by refine ⟨fun j ↦ τ.app _ (default : X), fun φ ↦ ?_⟩ diff --git a/Mathlib/Combinatorics/Hall/Basic.lean b/Mathlib/Combinatorics/Hall/Basic.lean index b109b85969039b..755e153f89abf1 100644 --- a/Mathlib/Combinatorics/Hall/Basic.lean +++ b/Mathlib/Combinatorics/Hall/Basic.lean @@ -86,7 +86,7 @@ theorem hallMatchingsOn.nonempty {ι : Type u} {α : Type v} [DecidableEq α] (t def hallMatchingsFunctor {ι : Type u} {α : Type v} (t : ι → Finset α) : (Finset ι)ᵒᵖ ⥤ Type (max u v) where obj ι' := hallMatchingsOn t ι'.unop - map {_ _} g := TypeCat.ofHom (hallMatchingsOn.restrict t (CategoryTheory.leOfHom g.unop)) + map {_ _} g := ↾ (hallMatchingsOn.restrict t (CategoryTheory.leOfHom g.unop)) instance hallMatchingsOn.finite {ι : Type u} {α : Type v} (t : ι → Finset α) (ι' : Finset ι) : Finite (hallMatchingsOn t ι') := by diff --git a/Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean b/Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean index 96658d16ed7079..02ccc8740ac7f2 100644 --- a/Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean +++ b/Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean @@ -257,7 +257,7 @@ The functor assigning, to a finite set in `V`, the set of connected components i @[simps] def componentComplFunctor : (Finset V)ᵒᵖ ⥤ Type u where obj K := G.ComponentCompl K.unop - map f := TypeCat.ofHom (ComponentCompl.hom (le_of_op_hom f)) + map f := ↾ (ComponentCompl.hom (le_of_op_hom f)) map_id _ := by ext simp [ComponentCompl.hom_refl] diff --git a/Mathlib/Combinatorics/SimpleGraph/Finsubgraph.lean b/Mathlib/Combinatorics/SimpleGraph/Finsubgraph.lean index c5bad294b194be..a5ae54d1af2d5c 100644 --- a/Mathlib/Combinatorics/SimpleGraph/Finsubgraph.lean +++ b/Mathlib/Combinatorics/SimpleGraph/Finsubgraph.lean @@ -147,7 +147,7 @@ def FinsubgraphHom.restrict {G' G'' : G.Finsubgraph} (h : G'' ≤ G') (f : G' def finsubgraphHomFunctor (G : SimpleGraph V) (F : SimpleGraph W) : G.Finsubgraphᵒᵖ ⥤ Type (max u v) where obj G' := G'.unop →fg F - map g := TypeCat.ofHom (fun f ↦ f.restrict (CategoryTheory.leOfHom g.unop)) + map g := ↾ (fun f ↦ f.restrict (CategoryTheory.leOfHom g.unop)) /-- If every finite subgraph of a graph `G` has a homomorphism to a finite graph `F`, then there is a homomorphism from the whole of `G` to `F`. -/ diff --git a/Mathlib/Condensed/Discrete/Colimit.lean b/Mathlib/Condensed/Discrete/Colimit.lean index 3a1111c814b67f..5648000d794b74 100644 --- a/Mathlib/Condensed/Discrete/Colimit.lean +++ b/Mathlib/Condensed/Discrete/Colimit.lean @@ -182,7 +182,7 @@ The functor which takes a finite set to the set of maps into `F(*)` for a preshe @[simps obj map] def finYoneda : FintypeCat.{u}ᵒᵖ ⥤ Type (u + 1) where obj X := X.unop → F.obj (toProfinite.op.obj ⟨of <| PUnit.{u + 1}⟩) - map f := TypeCat.ofHom (fun g ↦ g ∘ f.unop) + map f := ↾ (fun g ↦ g ∘ f.unop) /-- `locallyConstantPresheaf` restricted to finite sets is isomorphic to `finYoneda F`. -/ @[simps! hom_app] @@ -191,8 +191,8 @@ def locallyConstantIsoFinYoneda : ⟨of <| PUnit.{u + 1}⟩))) ≅ finYoneda F := NatIso.ofComponents fun Y ↦ { - hom := TypeCat.ofHom (fun f ↦ f.1) - inv := TypeCat.ofHom fun f ↦ ⟨f, @IsLocallyConstant.of_discrete _ _ _ ⟨rfl⟩ _⟩ } + hom := ↾ (fun f ↦ f.1) + inv := ↾ fun f ↦ ⟨f, @IsLocallyConstant.of_discrete _ _ _ ⟨rfl⟩ _⟩ } /-- A finite set as a coproduct cocone in `Profinite` over itself. -/ def fintypeCatAsCofan (X : Profinite) : @@ -225,7 +225,7 @@ def isoFinYonedaComponents (X : Profinite.{u}) [Finite X] : @[simp] lemma isoFinYonedaComponents_hom (X : Profinite.{u}) [Finite X] : (isoFinYonedaComponents F X).hom = - TypeCat.ofHom (fun y x ↦ F.map ((Profinite.of PUnit.{u + 1}).const x).op y) := + ↾ (fun y x ↦ F.map ((Profinite.of PUnit.{u + 1}).const x).op y) := rfl lemma isoFinYonedaComponents_hom_apply (X : Profinite.{u}) [Finite X] (y : F.obj ⟨X⟩) (x : X) : @@ -474,14 +474,14 @@ The functor which takes a finite set to the set of maps into `F(*)` for a preshe @[simps] def finYoneda : FintypeCat.{u}ᵒᵖ ⥤ Type u where obj X := X.unop → F.obj (toLightProfinite.op.obj ⟨of PUnit.{u + 1}⟩) - map f := TypeCat.ofHom fun g ↦ g ∘ f.unop + map f := ↾ fun g ↦ g ∘ f.unop /-- `locallyConstantPresheaf` restricted to finite sets is isomorphic to `finYoneda F`. -/ def locallyConstantIsoFinYoneda : toLightProfinite.op ⋙ (locallyConstantPresheaf (F.obj (toLightProfinite.op.obj ⟨of PUnit.{u + 1}⟩))) ≅ finYoneda F := NatIso.ofComponents fun Y ↦ { - hom := TypeCat.ofHom fun f ↦ f.1 - inv := TypeCat.ofHom fun f ↦ ⟨f, @IsLocallyConstant.of_discrete _ _ _ ⟨rfl⟩ _⟩ } + hom := ↾ fun f ↦ f.1 + inv := ↾ fun f ↦ ⟨f, @IsLocallyConstant.of_discrete _ _ _ ⟨rfl⟩ _⟩ } /-- A finite set as a coproduct cocone in `LightProfinite` over itself. -/ def fintypeCatAsCofan (X : LightProfinite) : @@ -513,7 +513,7 @@ def isoFinYonedaComponents (X : LightProfinite.{u}) [Finite X] : @[simp] lemma isoFinYonedaComponents_hom (X : LightProfinite.{u}) [Finite X] : (isoFinYonedaComponents F X).hom = - TypeCat.ofHom (fun y x ↦ F.map ((LightProfinite.of PUnit.{u + 1}).const x).op y) := + ↾ (fun y x ↦ F.map ((LightProfinite.of PUnit.{u + 1}).const x).op y) := rfl lemma isoFinYonedaComponents_hom_apply (X : LightProfinite.{u}) [Finite X] (y : F.obj ⟨X⟩) diff --git a/Mathlib/Condensed/Discrete/LocallyConstant.lean b/Mathlib/Condensed/Discrete/LocallyConstant.lean index 2b3e805a95af8c..db53e670dad14a 100644 --- a/Mathlib/Condensed/Discrete/LocallyConstant.lean +++ b/Mathlib/Condensed/Discrete/LocallyConstant.lean @@ -85,8 +85,8 @@ maps. def functorToPresheaves : Type (max u w) ⥤ ((CompHausLike.{u} P)ᵒᵖ ⥤ Type (max u w)) where obj X := { obj := fun ⟨S⟩ ↦ (LocallyConstant S X) - map f := TypeCat.ofHom (fun g ↦ g.comap f.unop.hom.hom) } - map f := { app _ := TypeCat.ofHom (fun t ↦ t.map f) } + map f := ↾ (fun g ↦ g.comap f.unop.hom.hom) } + map f := { app _ := ↾ (fun t ↦ t.map f) } /-- Locally constant maps are the same as continuous maps when the target is equipped with the discrete @@ -97,8 +97,8 @@ def locallyConstantIsoContinuousMap (Y X : Type*) [TopologicalSpace Y] : LocallyConstant Y X ≅ C(Y, TopCat.discrete.obj X) := letI : TopologicalSpace X := ⊥ haveI : DiscreteTopology X := ⟨rfl⟩ - { hom := TypeCat.ofHom fun f ↦ (f : C(Y, X)) - inv := TypeCat.ofHom fun f ↦ ⟨f, (IsLocallyConstant.iff_continuous f).mpr f.2⟩ } + { hom := ↾ fun f ↦ (f : C(Y, X)) + inv := ↾ fun f ↦ ⟨f, (IsLocallyConstant.iff_continuous f).mpr f.2⟩ } section Adjunction @@ -122,7 +122,7 @@ noncomputable def sigmaIso [HasExplicitFiniteCoproducts.{u} P] : (finiteCoproduc lemma sigmaComparison_comp_sigmaIso [HasExplicitFiniteCoproducts.{u} P] (X : (CompHausLike.{u} P)ᵒᵖ ⥤ Type (max u w)) : (X.mapIso (sigmaIso r).op).hom ≫ sigmaComparison X (fun a ↦ (fiber r a).1) ≫ - TypeCat.ofHom (fun g ↦ g a) = X.map (sigmaIncl r a).op := by + ↾ (fun g ↦ g a) = X.map (sigmaIncl r a).op := by ext simp only [Functor.mapIso_hom, Iso.op_hom, sigmaComparison, TypeCat.Fun.toFun_apply, CategoryTheory.comp_apply, ConcreteCategory.hom_ofHom, TypeCat.Fun.coe_mk, @@ -149,7 +149,7 @@ noncomputable def counitAppApp (S : CompHausLike.{u} P) (Y : (CompHausLike.{u} P)ᵒᵖ ⥤ Type (max u w)) [PreservesFiniteProducts Y] [HasExplicitFiniteCoproducts.{u} P] : LocallyConstant S (Y.obj (op (CompHausLike.of P PUnit.{u + 1}))) ⟶ Y.obj ⟨S⟩ := - TypeCat.ofHom fun r ↦ (inv (sigmaComparison Y (fun a ↦ (fiber r a).1)) ≫ + ↾ fun r ↦ (inv (sigmaComparison Y (fun a ↦ (fiber r a).1)) ≫ (Y.mapIso (sigmaIso r).op).inv) (counitAppAppImage r) -- This is the key lemma to prove naturality of the counit: @@ -301,13 +301,13 @@ The unit of the adjunction is given by mapping each element to the corresponding -/ @[simps] def unit : 𝟭 _ ⟶ functor P hs ⋙ (sheafSections _ _).obj ⟨CompHausLike.of P PUnit.{u + 1}⟩ where - app _ := TypeCat.ofHom (fun x ↦ LocallyConstant.const _ x) + app _ := ↾ (fun x ↦ LocallyConstant.const _ x) /-- The unit of the adjunction is an iso. -/ noncomputable def unitIso : 𝟭 (Type (max u w)) ≅ functor.{u, w} P hs ⋙ (sheafSections _ _).obj ⟨CompHausLike.of P PUnit.{u + 1}⟩ where hom := unit P hs - inv := { app _ := TypeCat.ofHom (fun f ↦ f.toFun PUnit.unit) } + inv := { app _ := ↾ (fun f ↦ f.toFun PUnit.unit) } lemma adjunction_left_triangle [HasExplicitFiniteCoproducts.{u} P] (X : Type (max u w)) : functorToPresheaves.{u, w}.map ((unit P hs).app X) ≫ diff --git a/Mathlib/Condensed/Light/Functors.lean b/Mathlib/Condensed/Light/Functors.lean index ebe3e499eeebe0..b33debb9d3c4f7 100644 --- a/Mathlib/Condensed/Light/Functors.lean +++ b/Mathlib/Condensed/Light/Functors.lean @@ -56,8 +56,8 @@ noncomputable def lightProfiniteToLightCondSetIsoTopCatToLightCondSet : lightProfiniteToLightCondSet.{u} ≅ LightProfinite.toTopCat.{u} ⋙ topCatToLightCondSet.{u} := dsimp% NatIso.ofComponents fun X ↦ FullyFaithful.preimageIso (fullyFaithfulSheafToPresheaf _ _) <| NatIso.ofComponents fun S ↦ { - hom := TypeCat.ofHom (fun f ↦ { toFun := f.hom }) - inv := TypeCat.ofHom (fun f ↦ InducedCategory.homMk (TopCat.ofHom f)) } + hom := ↾ (fun f ↦ { toFun := f.hom }) + inv := ↾ (fun f ↦ InducedCategory.homMk (TopCat.ofHom f)) } /-- The functor from `LightProfinite` to `LightCondSet` preserves countable limits. diff --git a/Mathlib/Condensed/Light/TopCatAdjunction.lean b/Mathlib/Condensed/Light/TopCatAdjunction.lean index 29248959e48c5d..88a26fb9f0a59f 100644 --- a/Mathlib/Condensed/Light/TopCatAdjunction.lean +++ b/Mathlib/Condensed/Light/TopCatAdjunction.lean @@ -104,7 +104,7 @@ lemma topCatAdjunctionCounit_bijective (X : TopCat.{u}) : @[simps hom_app] noncomputable def topCatAdjunctionUnit (X : LightCondSet.{u}) : X ⟶ X.toTopCat.toLightCondSet where hom := { - app S := TypeCat.ofHom fun x ↦ { + app S := ↾ fun x ↦ { toFun := fun s ↦ X.obj.map ((of PUnit.{u + 1}).const s).op x continuous_toFun := by suffices ∀ (i : (T : LightProfinite.{u}) × X.obj.obj ⟨T⟩), diff --git a/Mathlib/Condensed/TopCatAdjunction.lean b/Mathlib/Condensed/TopCatAdjunction.lean index ff0d412d627de0..fe255a498ce803 100644 --- a/Mathlib/Condensed/TopCatAdjunction.lean +++ b/Mathlib/Condensed/TopCatAdjunction.lean @@ -114,7 +114,7 @@ lemma topCatAdjunctionCounit_bijective (X : TopCat.{u + 1}) : @[simps hom_app] noncomputable def topCatAdjunctionUnit (X : CondensedSet.{u}) : X ⟶ X.toTopCat.toCondensedSet where hom := { - app S := TypeCat.ofHom fun x ↦ { + app S := ↾ fun x ↦ { toFun := fun s ↦ X.obj.map ((of PUnit.{u + 1}).const s).op x continuous_toFun := by suffices ∀ (i : (T : CompHaus.{u}) × X.obj.obj ⟨T⟩), diff --git a/Mathlib/Condensed/TopComparison.lean b/Mathlib/Condensed/TopComparison.lean index b9470ce5dfbe0b..abd54d2844c05f 100644 --- a/Mathlib/Condensed/TopComparison.lean +++ b/Mathlib/Condensed/TopComparison.lean @@ -128,7 +128,7 @@ noncomputable def topCatToSheafCompHausLike : have := CompHausLike.preregular hs TopCat.{max u w} ⥤ Sheaf (coherentTopology (CompHausLike.{u} P)) (Type (max u w)) where obj X := X.toSheafCompHausLike P hs - map f := ⟨⟨fun _ ↦ TypeCat.ofHom (fun g ↦ f.hom.comp g), by aesop⟩⟩ + map f := ⟨⟨fun _ ↦ ↾ (fun g ↦ f.hom.comp g), by aesop⟩⟩ end diff --git a/Mathlib/Control/Fold.lean b/Mathlib/Control/Fold.lean index 2e43c44c26535e..d1432f1677ab88 100644 --- a/Mathlib/Control/Fold.lean +++ b/Mathlib/Control/Fold.lean @@ -111,14 +111,14 @@ abbrev Foldl (α : Type u) : Type u := (End α)ᵐᵒᵖ def Foldl.mk (f : α → α) : Foldl α := - op (TypeCat.ofHom f) + op (↾ f) def Foldl.get (x : Foldl α) : α → α := ConcreteCategory.hom (unop x) @[simps] def Foldl.ofFreeMonoid (f : β → α → β) : FreeMonoid α →* Monoid.Foldl β where - toFun xs := op <| TypeCat.ofHom (flip (List.foldl f) (FreeMonoid.toList xs)) + toFun xs := op <| ↾ (flip (List.foldl f) (FreeMonoid.toList xs)) map_one' := rfl map_mul' := by intros @@ -129,14 +129,14 @@ abbrev Foldr (α : Type u) : Type u := End α def Foldr.mk (f : α → α) : Foldr α := - TypeCat.ofHom f + ↾ f def Foldr.get (x : Foldr α) : α → α := ConcreteCategory.hom x @[simps] def Foldr.ofFreeMonoid (f : α → β → β) : FreeMonoid α →* Monoid.Foldr β where - toFun xs := TypeCat.ofHom (flip (List.foldr f) (FreeMonoid.toList xs)) + toFun xs := ↾ (flip (List.foldr f) (FreeMonoid.toList xs)) map_one' := rfl map_mul' _ _ := by apply ConcreteCategory.ext diff --git a/Mathlib/Geometry/Manifold/Sheaf/Smooth.lean b/Mathlib/Geometry/Manifold/Sheaf/Smooth.lean index 9c16e146a25116..c0cfa12a6dc185 100644 --- a/Mathlib/Geometry/Manifold/Sheaf/Smooth.lean +++ b/Mathlib/Geometry/Manifold/Sheaf/Smooth.lean @@ -129,7 +129,7 @@ def smoothSheaf.evalAt (x : TopCat.of M) (U : OpenNhds x) @[simp, reassoc, elementwise] lemma smoothSheaf.ι_evalHom (x : TopCat.of M) (U) : colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheaf IM I M N).obj) U ≫ smoothSheaf.evalHom IM I N x = - TypeCat.ofHom (smoothSheaf.evalAt IM I N x (unop U)) := + ↾ (smoothSheaf.evalAt IM I N x (unop U)) := colimit.ι_desc _ _ /-- The `eval` map is surjective at `x`. -/ @@ -159,7 +159,7 @@ by pre-composing with `f`. -/ def ContMDiff.smoothSheafHom (f : M → P) (hf : ContMDiff IM IP ∞ f) : smoothSheaf IP I P N ⟶ (TopCat.Sheaf.pushforward _ (TopCat.ofHom ⟨f, hf.continuous⟩)).obj (smoothSheaf IM I M N) where - hom.app U := TypeCat.ofHom fun g ↦ ⟨g ∘ Set.restrictPreimage _ f, by + hom.app U := ↾ fun g ↦ ⟨g ∘ Set.restrictPreimage _ f, by apply ContMDiff.comp (I' := IP) g.2 rw [← ContMDiff.subtypeVal_comp_iff] exact hf.comp contMDiff_subtype_val⟩ @@ -316,7 +316,7 @@ def smoothSheafCommRing.forgetStalk (x : TopCat.of M) : preservesColimitIso (forget CommRingCat) _ @[simp, reassoc, elementwise] lemma smoothSheafCommRing.ι_forgetStalk_hom (x : TopCat.of M) (U) : - dsimp% TypeCat.ofHom (colimit.ι ((OpenNhds.inclusion x).op ⋙ + dsimp% ↾ (colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheafCommRing IM I M R).presheaf) U).hom ≫ (forgetStalk IM I M R x).hom = colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheaf IM I M R).presheaf) U := ι_preservesColimitIso_hom (forget CommRingCat) _ _ @@ -324,7 +324,7 @@ def smoothSheafCommRing.forgetStalk (x : TopCat.of M) : @[simp, reassoc, elementwise] lemma smoothSheafCommRing.ι_forgetStalk_inv (x : TopCat.of M) (U) : colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheaf IM I M R).presheaf) U ≫ (smoothSheafCommRing.forgetStalk IM I M R x).inv = - TypeCat.ofHom (colimit.ι ((OpenNhds.inclusion x).op ⋙ + ↾ (colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheafCommRing IM I M R).presheaf) U).hom := by dsimp rw [Iso.comp_inv_eq, ← smoothSheafCommRing.ι_forgetStalk_hom] @@ -366,7 +366,7 @@ set_option backward.isDefEq.respectTransparency false in @[simp, reassoc, elementwise] lemma smoothSheafCommRing.forgetStalk_inv_comp_eval (x : TopCat.of M) : (smoothSheafCommRing.forgetStalk IM I M R x).inv ≫ - TypeCat.ofHom (smoothSheafCommRing.evalHom IM I M R x).hom = + ↾ (smoothSheafCommRing.evalHom IM I M R x).hom = smoothSheaf.evalHom _ _ _ _ := by apply Limits.colimit.hom_ext intro U @@ -378,7 +378,7 @@ set_option backward.isDefEq.respectTransparency false in @[simp, reassoc, elementwise] lemma smoothSheafCommRing.forgetStalk_hom_comp_evalHom (x : TopCat.of M) : (smoothSheafCommRing.forgetStalk IM I M R x).hom ≫ (smoothSheaf.evalHom IM I R x) = - TypeCat.ofHom (smoothSheafCommRing.evalHom _ _ _ _ _) := by + ↾ (smoothSheafCommRing.evalHom _ _ _ _ _) := by simp_rw [← CategoryTheory.Iso.eq_inv_comp] rw [← smoothSheafCommRing.forgetStalk_inv_comp_eval] diff --git a/Mathlib/Geometry/RingedSpace/LocallyRingedSpace/HasColimits.lean b/Mathlib/Geometry/RingedSpace/LocallyRingedSpace/HasColimits.lean index 900160b51dc462..c34a5d458c114e 100644 --- a/Mathlib/Geometry/RingedSpace/LocallyRingedSpace/HasColimits.lean +++ b/Mathlib/Geometry/RingedSpace/LocallyRingedSpace/HasColimits.lean @@ -179,8 +179,8 @@ theorem imageBasicOpen_image_preimage : (coequalizer.π f.toShHom g.toShHom).hom.base ⁻¹' ((coequalizer.π f.toShHom g.toShHom).hom.base '' (imageBasicOpen f g U s).1) = (imageBasicOpen f g U s).1 := by - fapply Types.coequalizer_preimage_image_eq_of_preimage_eq (TypeCat.ofHom f.base) - (TypeCat.ofHom g.base) (TypeCat.ofHom (coequalizer.π f.toShHom g.toShHom).hom.base) + fapply Types.coequalizer_preimage_image_eq_of_preimage_eq (↾ f.base) + (↾ g.base) (↾ (coequalizer.π f.toShHom g.toShHom).hom.base) · ext simp only [TypeCat.Fun.toFun_apply, comp_apply, ConcreteCategory.hom_ofHom, TypeCat.Fun.coe_mk, ← TopCat.comp_app, ← PresheafedSpace.comp_base] diff --git a/Mathlib/RepresentationTheory/Homological/Resolution.lean b/Mathlib/RepresentationTheory/Homological/Resolution.lean index 5fe4903c8b0f83..c1b3da9d974472 100644 --- a/Mathlib/RepresentationTheory/Homological/Resolution.lean +++ b/Mathlib/RepresentationTheory/Homological/Resolution.lean @@ -88,7 +88,7 @@ def classifyingSpaceUniversalCover [Monoid G] : SimplicialObject (Action (Type u) G) where obj n := Action.ofMulAction G (Fin (n.unop.len + 1) → G) map f := - { hom := TypeCat.ofHom (fun x => x ∘ f.unop.toOrderHom) + { hom := ↾ (fun x => x ∘ f.unop.toOrderHom) comm := fun _ => rfl } map_id _ := rfl map_comp _ _ := rfl @@ -133,7 +133,7 @@ extra degeneracy. -/ def extraDegeneracyAugmentedCechNerve : ExtraDegeneracy (Arrow.mk <| terminal.from G).augmentedCechNerve := AugmentedCechNerve.extraDegeneracy (Arrow.mk <| terminal.from G) - ⟨TypeCat.ofHom (fun _ => (1 : G)), by cat_disch⟩ + ⟨↾ (fun _ => (1 : G)), by cat_disch⟩ /-- The universal cover of the classifying space of `G` as a simplicial set, augmented by the map from `Fin 1 → G` to the terminal object in `Type u`, has an extra degeneracy. -/ diff --git a/Mathlib/RingTheory/Invariant/Profinite.lean b/Mathlib/RingTheory/Invariant/Profinite.lean index d6052e0f3b1908..218ea0e249e077 100644 --- a/Mathlib/RingTheory/Invariant/Profinite.lean +++ b/Mathlib/RingTheory/Invariant/Profinite.lean @@ -65,7 +65,7 @@ lemma Algebra.IsInvariant.exists_smul_of_under_eq_of_profinite let B' := FixedPoints.subalgebra A B let F : OpenNormalSubgroup G ⥤ Type _ := { obj N := { g : G ⧸ N.1.1 // Q.under (B' N.1.1) = g • P.under (B' N.1.1) } - map {N N'} f := TypeCat.ofHom fun x ↦ ⟨(QuotientGroup.map _ _ (.id _) (leOfHom f)) x.1, by + map {N N'} f := ↾ fun x ↦ ⟨(QuotientGroup.map _ _ (.id _) (leOfHom f)) x.1, by have h : B' N'.1.1 ≤ B' N.1.1 := fun x hx n ↦ hx ⟨_, f.le n.2⟩ obtain ⟨x, hx⟩ := x obtain ⟨x, rfl⟩ := QuotientGroup.mk_surjective x @@ -136,7 +136,7 @@ def Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor commutes' := Quotient.ind fun _ ↦ rfl } { σ' // f.comp (Ideal.Quotient.stabilizerHom (Q.under B') P (G ⧸ N.1.1) σ') = σ.toAlgHom.comp f } - map {N N'} i := TypeCat.ofHom fun x ↦ ⟨⟨(QuotientGroup.map _ _ (.id _) (leOfHom i)) x.1, + map {N N'} i := ↾ fun x ↦ ⟨⟨(QuotientGroup.map _ _ (.id _) (leOfHom i)) x.1, Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor_aux Q i.le x.1.1 x.1.2⟩, by have h : FixedPoints.subalgebra A B N'.1.1 ≤ FixedPoints.subalgebra A B N.1.1 := fun x hx n ↦ hx ⟨_, i.le n.2⟩ diff --git a/Mathlib/Topology/Category/CompHausLike/SigmaComparison.lean b/Mathlib/Topology/Category/CompHausLike/SigmaComparison.lean index 856b3e34039b5f..9a037f4071e8a8 100644 --- a/Mathlib/Topology/Category/CompHausLike/SigmaComparison.lean +++ b/Mathlib/Topology/Category/CompHausLike/SigmaComparison.lean @@ -41,7 +41,7 @@ The comparison map from the value of a condensed set on a finite coproduct to th values on the components. -/ def sigmaComparison : X.obj ⟨(of P ((a : α) × σ a))⟩ ⟶ ((a : α) → X.obj ⟨of P (σ a)⟩) := - TypeCat.ofHom fun x a ↦ X.map (ofHom _ ⟨Sigma.mk a, continuous_sigmaMk⟩).op x + ↾ fun x a ↦ X.map (ofHom _ ⟨Sigma.mk a, continuous_sigmaMk⟩).op x set_option backward.isDefEq.respectTransparency false in theorem sigmaComparison_eq_comp_isos : sigmaComparison X σ = diff --git a/Mathlib/Topology/Category/Compactum.lean b/Mathlib/Topology/Category/Compactum.lean index 70cdbcf5a454d4..a823b827e090ac 100644 --- a/Mathlib/Topology/Category/Compactum.lean +++ b/Mathlib/Topology/Category/Compactum.lean @@ -378,7 +378,7 @@ theorem continuous_of_hom {X Y : Compactum} (f : X ⟶ Y) : Continuous f := by noncomputable def ofTopologicalSpace (X : Type*) [TopologicalSpace X] [CompactSpace X] [T2Space X] : Compactum where A := X - a := TypeCat.ofHom Ultrafilter.lim + a := ↾ Ultrafilter.lim unit := by ext x exact lim_eq (pure_le_nhds _) @@ -406,7 +406,7 @@ noncomputable def ofTopologicalSpace (X : Type*) [TopologicalSpace X] [CompactSp /-- Any continuous map between Compacta is a morphism of compacta. -/ def homOfContinuous {X Y : Compactum} (f : X → Y) (cont : Continuous f) : X ⟶ Y := - { f := TypeCat.ofHom f + { f := ↾ f h := by rw [continuous_iff_ultrafilter] at cont ext (F : Ultrafilter X) diff --git a/Mathlib/Topology/Category/LightProfinite/Basic.lean b/Mathlib/Topology/Category/LightProfinite/Basic.lean index f3667d70b47a1a..4ea4b53a413f5e 100644 --- a/Mathlib/Topology/Category/LightProfinite/Basic.lean +++ b/Mathlib/Topology/Category/LightProfinite/Basic.lean @@ -99,7 +99,7 @@ def FintypeCat.toLightProfinite : FintypeCat ⥤ LightProfinite where /-- `FintypeCat.toLightProfinite` is fully faithful. -/ def FintypeCat.toLightProfiniteFullyFaithful : toLightProfinite.FullyFaithful where - preimage f := InducedCategory.homMk (TypeCat.ofHom (f.hom.hom.1)) + preimage f := InducedCategory.homMk (↾ (f.hom.hom.1)) map_preimage _ := rfl preimage_map _ := rfl diff --git a/Mathlib/Topology/Category/Profinite/Basic.lean b/Mathlib/Topology/Category/Profinite/Basic.lean index fada95742680b5..fcb7784ae98d28 100644 --- a/Mathlib/Topology/Category/Profinite/Basic.lean +++ b/Mathlib/Topology/Category/Profinite/Basic.lean @@ -147,7 +147,7 @@ def FintypeCat.toProfinite : FintypeCat ⥤ Profinite where /-- `FintypeCat.toLightProfinite` is fully faithful. -/ def FintypeCat.toProfiniteFullyFaithful : toProfinite.FullyFaithful where - preimage f := InducedCategory.homMk <| TypeCat.ofHom (f : _ → _) + preimage f := InducedCategory.homMk <| ↾ (f : _ → _) map_preimage _ := rfl preimage_map _ := rfl diff --git a/Mathlib/Topology/Category/Profinite/Extend.lean b/Mathlib/Topology/Category/Profinite/Extend.lean index 2b83cb1d37c63a..697343bd352d73 100644 --- a/Mathlib/Topology/Category/Profinite/Extend.lean +++ b/Mathlib/Topology/Category/Profinite/Extend.lean @@ -47,7 +47,7 @@ lemma exists_hom (hc : IsLimit c) {X : FintypeCat} (f : c.pt ⟶ toProfinite.obj let f' : LocallyConstant c.pt (toProfinite.obj X) := ⟨f, (IsLocallyConstant.iff_continuous _).mpr f.hom.hom.continuous⟩ obtain ⟨i, g, h⟩ := exists_locallyConstant.{_, u} c hc f' - refine ⟨i, ⟨TypeCat.ofHom g⟩, ?_⟩ + refine ⟨i, ⟨↾ g⟩, ?_⟩ ext x exact LocallyConstant.congr_fun h x diff --git a/Mathlib/Topology/Category/TopCat/Yoneda.lean b/Mathlib/Topology/Category/TopCat/Yoneda.lean index 6798dd37b96528..e9902019ef9e58 100644 --- a/Mathlib/Topology/Category/TopCat/Yoneda.lean +++ b/Mathlib/Topology/Category/TopCat/Yoneda.lean @@ -36,7 +36,7 @@ A universe polymorphic "Yoneda presheaf" on `C` given by continuous maps into a @[simps] def yonedaPresheaf : Cᵒᵖ ⥤ Type (max w w') where obj X := C(F.obj (unop X), Y) - map f := TypeCat.ofHom (fun g ↦ ContinuousMap.comp g (F.map f.unop).hom) + map f := ↾ (fun g ↦ ContinuousMap.comp g (F.map f.unop).hom) /-- A universe polymorphic Yoneda presheaf on `TopCat` given by continuous maps into a topological @@ -45,7 +45,7 @@ space `Y`. @[simps] def yonedaPresheaf' : TopCat.{w}ᵒᵖ ⥤ Type (max w w') where obj X := C((unop X).1, Y) - map f := TypeCat.ofHom fun g ↦ ContinuousMap.comp g + map f := ↾ fun g ↦ ContinuousMap.comp g (ConcreteCategory.hom f.unop) theorem comp_yonedaPresheaf' : yonedaPresheaf F Y = F.op ⋙ yonedaPresheaf' Y := rfl diff --git a/Mathlib/Topology/Homotopy/Lifting.lean b/Mathlib/Topology/Homotopy/Lifting.lean index a240ddcae7f491..38f9af7fabecf6 100644 --- a/Mathlib/Topology/Homotopy/Lifting.lean +++ b/Mathlib/Topology/Homotopy/Lifting.lean @@ -393,7 +393,7 @@ open CategoryTheory https://ncatlab.org/nlab/show/monodromy. -/ @[simps] noncomputable def monodromyFunctor : FundamentalGroupoid X ⥤ Type _ where obj x := p ⁻¹' {x.as} - map f := TypeCat.ofHom (cov.monodromy f) + map f := ↾ (cov.monodromy f) map_id _ := by ext x : 3; simpa using congr_fun cov.monodromy_refl x map_comp _ _ := by ext : 3; simpa using cov.monodromy_trans_apply _ _ _ diff --git a/Mathlib/Topology/Sheaves/LocalPredicate.lean b/Mathlib/Topology/Sheaves/LocalPredicate.lean index dbd6efe16d6c83..98876922ae8c33 100644 --- a/Mathlib/Topology/Sheaves/LocalPredicate.lean +++ b/Mathlib/Topology/Sheaves/LocalPredicate.lean @@ -226,7 +226,7 @@ end PrelocalPredicate @[simps] def subpresheafToTypes (P : PrelocalPredicate T) : Presheaf (Type _) X where obj U := { f : ∀ x : U.unop, T x // P.pred f } - map i := TypeCat.ofHom fun f ↦ ⟨fun x ↦ f.1 (i.unop x), P.res i.unop f.1 f.2⟩ + map i := ↾ fun f ↦ ⟨fun x ↦ f.1 (i.unop x), P.res i.unop f.1 f.2⟩ namespace subpresheafToTypes @@ -235,7 +235,7 @@ variable (P : PrelocalPredicate T) /-- The natural transformation including the subpresheaf of functions satisfying a local predicate into the presheaf of all functions. -/ -def subtype : subpresheafToTypes P ⟶ presheafToTypes X T where app _ := TypeCat.ofHom (fun f ↦ f.1) +def subtype : subpresheafToTypes P ⟶ presheafToTypes X T where app _ := ↾ (fun f ↦ f.1) open TopCat.Presheaf @@ -286,7 +286,7 @@ def subsheafToTypes (P : LocalPredicate T) : Sheaf (Type _) X := def LocalPredicate.cocone (P : LocalPredicate T) (x : X) : Cocone ((OpenNhds.inclusion x).op ⋙ subpresheafToTypes P.toPrelocalPredicate) where pt := T x - ι := { app U := TypeCat.ofHom (fun f ↦ f.1 ⟨x, (unop U).2⟩) } + ι := { app U := ↾ (fun f ↦ f.1 ⟨x, (unop U).2⟩) } /-- There is a canonical map from the stalk to the original fiber, given by evaluating sections. -/ @@ -361,8 +361,8 @@ the presheaf of continuous functions. def subpresheafContinuousPrelocalIsoPresheafToTop {X : TopCat.{u}} (T : TopCat.{u}) : subpresheafToTypes (continuousPrelocal X T) ≅ presheafToTop X T := NatIso.ofComponents fun X ↦ - { hom := TypeCat.ofHom <| by rintro ⟨f, c⟩; exact ofHom ⟨f, c⟩ - inv := TypeCat.ofHom <| by rintro ⟨f, c⟩; exact ⟨f, c⟩ } + { hom := ↾(by rintro ⟨f, c⟩; exact ofHom ⟨f, c⟩) + inv := ↾(by rintro ⟨f, c⟩; exact ⟨f, c⟩) } /-- The sheaf of continuous functions on `X` with values in a space `T`. -/ diff --git a/Mathlib/Topology/Sheaves/Points.lean b/Mathlib/Topology/Sheaves/Points.lean index a601c026560396..a2ab69e9988741 100644 --- a/Mathlib/Topology/Sheaves/Points.lean +++ b/Mathlib/Topology/Sheaves/Points.lean @@ -36,7 +36,7 @@ variable {X : Type u} [TopologicalSpace X] (x : X) `(Opens X, Opens.grothendieckTopology X)` corresponding to `x`. -/ def pointGrothendieckTopology : Point.{u} (grothendieckTopology X) where fiber.obj U := ULift.{u} (PLift (x ∈ U)) - fiber.map f := TypeCat.ofHom fun h ↦ ⟨⟨leOfHom f h.down.down⟩⟩ + fiber.map f := ↾ fun h ↦ ⟨⟨leOfHom f h.down.down⟩⟩ isCofiltered := { nonempty := ⟨⊤, ⟨⟨by simp⟩⟩⟩ cone_objs := by @@ -81,7 +81,7 @@ there is a (unique) morphism between the corresponding points of the site def pointGrothendieckTopologyHomEquiv {x y : X} : (pointGrothendieckTopology x ⟶ pointGrothendieckTopology y) ≃ x ⤳ y where toFun f := specializes_iff_forall_open.2 (fun U h₁ h₂ ↦ (f.hom.app ⟨U, h₁⟩ ⟨⟨h₂⟩⟩).down.down) - invFun s := { hom.app U := TypeCat.ofHom fun hU ↦ + invFun s := { hom.app U := ↾ fun hU ↦ ⟨⟨specializes_iff_forall_open.1 s _ U.2 hU.down.down⟩⟩ } left_inv _ := by subsingleton right_inv _ := rfl diff --git a/Mathlib/Topology/Sheaves/PresheafOfFunctions.lean b/Mathlib/Topology/Sheaves/PresheafOfFunctions.lean index 155abb87ee9654..8c68a7926a17c2 100644 --- a/Mathlib/Topology/Sheaves/PresheafOfFunctions.lean +++ b/Mathlib/Topology/Sheaves/PresheafOfFunctions.lean @@ -36,7 +36,7 @@ There is no requirement that the functions are continuous, here. -/ def presheafToTypes (T : X → Type*) : X.Presheaf (Type _) where obj U := ∀ x : U.unop, T x - map {_ V} i := TypeCat.ofHom (fun (g) (x : V.unop) => g (i.unop x)) + map {_ V} i := ↾ (fun (g) (x : V.unop) => g (i.unop x)) @[simp] theorem presheafToTypes_obj {T : X → Type*} {U : (Opens X)ᵒᵖ} : @@ -59,7 +59,7 @@ There is no requirement that the functions are continuous, here. -/ def presheafToType (T : Type*) : X.Presheaf (Type _) where obj U := U.unop → T - map {_ _} i := TypeCat.ofHom (fun g ↦ g ∘ i.unop) + map {_ _} i := ↾ (fun g ↦ g ∘ i.unop) @[simp] theorem presheafToType_obj {T : Type*} {U : (Opens X)ᵒᵖ} : diff --git a/Mathlib/Topology/Sheaves/Sheafify.lean b/Mathlib/Topology/Sheaves/Sheafify.lean index debf1f1976f041..404cb3a6abcef9 100644 --- a/Mathlib/Topology/Sheaves/Sheafify.lean +++ b/Mathlib/Topology/Sheaves/Sheafify.lean @@ -73,7 +73,7 @@ sending each section to its germs. (This forms the unit of the adjunction.) -/ def toSheafify : F ⟶ F.sheafify.1 where - app U := TypeCat.ofHom fun f ↦ ⟨fun x => F.germ _ x x.2 f, PrelocalPredicate.sheafifyOf + app U := ↾ fun f ↦ ⟨fun x => F.germ _ x x.2 f, PrelocalPredicate.sheafifyOf ⟨f, fun x => rfl⟩⟩ naturality U U' f := by ext x From d9c7e4280469125acd90d9af270397779e3055b2 Mon Sep 17 00:00:00 2001 From: Dagur Asgeirsson Date: Tue, 28 Apr 2026 09:06:40 -0600 Subject: [PATCH 6/6] wip --- Mathlib/Algebra/Category/ModuleCat/Basic.lean | 102 +++------------ Mathlib/CategoryTheory/Category/Cat.lean | 2 +- .../ConcreteCategory/Forget.lean | 2 + Mathlib/CategoryTheory/Types/Basic.lean | 4 +- Mathlib/CategoryTheory/Yoneda.lean | 4 +- .../CategoryTheory/MkConcreteCategory.lean | 119 +++++++++++++++--- MathlibTest/MkConcreteCategory.lean | 11 +- 7 files changed, 133 insertions(+), 111 deletions(-) diff --git a/Mathlib/Algebra/Category/ModuleCat/Basic.lean b/Mathlib/Algebra/Category/ModuleCat/Basic.lean index 360e6228545371..bcb88b987ff7a4 100644 --- a/Mathlib/Algebra/Category/ModuleCat/Basic.lean +++ b/Mathlib/Algebra/Category/ModuleCat/Basic.lean @@ -84,62 +84,28 @@ lemma coe_of (X : Type v) [Ring X] [Module R X] : (of R X : Type v) = X := example (X : Type v) [Ring X] [Module R X] : (of R X : Type v) = X := by with_reducible rfl example (M : ModuleCat.{v} R) : of R M = M := by with_reducible rfl -set_option backward.privateInPublic true in variable {R} in -/-- The type of morphisms in `ModuleCat R`. -/ -@[ext] -structure Hom (M N : ModuleCat.{v} R) where - private mk :: - /-- The underlying linear map. -/ - hom' : M →ₗ[R] N +mk_concrete_category (ModuleCat.{v} R) (· →ₗ[R] ·) (fun M ↦ .id (M := M)) (.comp · ·) -set_option backward.privateInPublic true in -set_option backward.privateInPublic.warn false in -instance moduleCategory : Category.{v, max (v + 1) u} (ModuleCat.{v} R) where - Hom M N := Hom M N - id _ := ⟨LinearMap.id⟩ - comp f g := ⟨g.hom'.comp f.hom'⟩ +/-- +info: ModuleCat.Hom.hom.{v, u} {R : Type u} [Ring R] {X Y : ModuleCat R} (f : X.Hom Y) : ↑X →ₗ[R] ↑Y +-/ +#guard_msgs in +#check ModuleCat.Hom.hom -set_option backward.privateInPublic true in -set_option backward.privateInPublic.warn false in -instance : ConcreteCategory (ModuleCat.{v} R) (· →ₗ[R] ·) where - hom := Hom.hom' - ofHom := Hom.mk +#check ModuleCat.hom_comp +#check ModuleCat.ofHom +#check ModuleCat.ofHom_hom +#check ModuleCat.hom_ofHom section variable {R} -/-- Turn a morphism in `ModuleCat` back into a `LinearMap`. -/ -abbrev Hom.hom {A B : ModuleCat.{v} R} (f : Hom A B) := - ConcreteCategory.hom (C := ModuleCat R) f - -/-- Typecheck a `LinearMap` as a morphism in `ModuleCat`. -/ -abbrev ofHom {X Y : Type v} [AddCommGroup X] [Module R X] [AddCommGroup Y] [Module R Y] - (f : X →ₗ[R] Y) : of R X ⟶ of R Y := - ConcreteCategory.ofHom (C := ModuleCat R) f - -/-- Use the `ConcreteCategory.hom` projection for `@[simps]` lemmas. -/ -def Hom.Simps.hom (A B : ModuleCat.{v} R) (f : Hom A B) := - f.hom - -initialize_simps_projections Hom (hom' → hom) - -/-! -The results below duplicate the `ConcreteCategory` simp lemmas, but we can keep them for `dsimp`. --/ - -@[simp] -lemma hom_id {M : ModuleCat.{v} R} : (𝟙 M : M ⟶ M).hom = LinearMap.id := rfl - /- Provided for rewriting. -/ lemma id_apply (M : ModuleCat.{v} R) (x : M) : (𝟙 M : M ⟶ M) x = x := by simp -@[simp] -lemma hom_comp {M N O : ModuleCat.{v} R} (f : M ⟶ N) (g : N ⟶ O) : - (f ≫ g).hom = g.hom.comp f.hom := rfl - /- Provided for rewriting. -/ lemma comp_apply {M N O : ModuleCat.{v} R} (f : M ⟶ N) (g : N ⟶ O) (x : M) : (f ≫ g) x = g (f x) := by simp @@ -148,53 +114,12 @@ lemma comp_apply {M N O : ModuleCat.{v} R} (f : M ⟶ N) (g : N ⟶ O) (x : M) : lemma hom_ext {M N : ModuleCat.{v} R} {f g : M ⟶ N} (hf : f.hom = g.hom) : f = g := Hom.ext hf -lemma hom_bijective {M N : ModuleCat.{v} R} : - Function.Bijective (Hom.hom : (M ⟶ N) → (M →ₗ[R] N)) where - left f g h := by cases f; cases g; simpa using h - right f := ⟨⟨f⟩, rfl⟩ - -/-- Convenience shortcut for `ModuleCat.hom_bijective.injective`. -/ -lemma hom_injective {M N : ModuleCat.{v} R} : - Function.Injective (Hom.hom : (M ⟶ N) → (M →ₗ[R] N)) := - hom_bijective.injective - -/-- Convenience shortcut for `ModuleCat.hom_bijective.surjective`. -/ -lemma hom_surjective {M N : ModuleCat.{v} R} : - Function.Surjective (Hom.hom : (M ⟶ N) → (M →ₗ[R] N)) := - hom_bijective.surjective - -@[simp] -lemma hom_ofHom {X Y : Type v} [AddCommGroup X] [Module R X] [AddCommGroup Y] - [Module R Y] (f : X →ₗ[R] Y) : (ofHom f).hom = f := rfl - -@[simp] -lemma ofHom_hom {M N : ModuleCat.{v} R} (f : M ⟶ N) : - ofHom (Hom.hom f) = f := rfl - -@[simp] -lemma ofHom_id {M : Type v} [AddCommGroup M] [Module R M] : ofHom LinearMap.id = 𝟙 (of R M) := rfl - -@[simp] -lemma ofHom_comp {M N O : Type v} [AddCommGroup M] [AddCommGroup N] [AddCommGroup O] [Module R M] - [Module R N] [Module R O] (f : M →ₗ[R] N) (g : N →ₗ[R] O) : - ofHom (g.comp f) = ofHom f ≫ ofHom g := - rfl - -/- Doesn't need to be `@[simp]` since `simp only` can solve this. -/ -lemma ofHom_apply {M N : Type v} [AddCommGroup M] [AddCommGroup N] [Module R M] [Module R N] - (f : M →ₗ[R] N) (x : M) : ofHom f x = f x := rfl - lemma inv_hom_apply {M N : ModuleCat.{v} R} (e : M ≅ N) (x : M) : e.inv (e.hom x) = x := by simp lemma hom_inv_apply {M N : ModuleCat.{v} R} (e : M ≅ N) (x : N) : e.hom (e.inv x) = x := by simp -/-- `ModuleCat.Hom.hom` bundled as an `Equiv`. -/ -def homEquiv {M N : ModuleCat.{v} R} : (M ⟶ N) ≃ (M →ₗ[R] N) where - toFun := Hom.hom - invFun := ofHom - set_option backward.privateInPublic true in set_option backward.privateInPublic.warn false in /-- The categorical equivalence between `ModuleCat` and `SemimoduleCat`. @@ -374,7 +299,9 @@ def homAddEquiv : (M ⟶ N) ≃+ (M →ₗ[R] N) := theorem subsingleton_of_isZero (h : IsZero M) : Subsingleton M := by refine subsingleton_of_forall_eq 0 (fun x ↦ ?_) - rw [← LinearMap.id_apply (R := R) x, ← ModuleCat.hom_id] + have := ModuleCat.hom_id (R := R) (X := M) + dsimp only at this + rw [← LinearMap.id_apply (R := R) x, ← this] simp only [(CategoryTheory.Limits.IsZero.iff_id_eq_zero M).mp h, hom_zero, LinearMap.zero_apply] lemma isZero_iff_subsingleton : IsZero M ↔ Subsingleton M where @@ -603,7 +530,8 @@ def ofHom₂ {M N P : ModuleCat.{u} R} (f : M →ₗ[R] N →ₗ[R] P) : /-- Turn a homomorphism into a bilinear map. -/ @[simps!] def Hom.hom₂ {M N P : ModuleCat.{u} R} (f : M ⟶ (of R (N ⟶ P))) : M →ₗ[R] N →ₗ[R] P := - (f ≫ ofHom homLinearEquiv.toLinearMap).hom + -- (f ≫ ofHom ((homLinearEquiv (M := N) (N := P)).toLinearMap)).hom + (f ≫ ofHom (X := of R (N ⟶ P)) (Y := of R (N →ₗ[R] P)) homLinearEquiv.toLinearMap).hom @[simp] lemma Hom.hom₂_ofHom₂ {M N P : ModuleCat.{u} R} (f : M →ₗ[R] N →ₗ[R] P) : (ofHom₂ f).hom₂ = f := rfl diff --git a/Mathlib/CategoryTheory/Category/Cat.lean b/Mathlib/CategoryTheory/Category/Cat.lean index fab181a6c0787a..a7c512dc731243 100644 --- a/Mathlib/CategoryTheory/Category/Cat.lean +++ b/Mathlib/CategoryTheory/Category/Cat.lean @@ -41,7 +41,7 @@ def Cat := namespace Cat instance : Inhabited Cat := - ⟨⟨Type u, CategoryTheory.types⟩⟩ + ⟨⟨Type u, inferInstance⟩⟩ -- TODO: maybe this coercion should be defined to be `objects.obj`? instance : CoeSort Cat (Type u) := diff --git a/Mathlib/CategoryTheory/ConcreteCategory/Forget.lean b/Mathlib/CategoryTheory/ConcreteCategory/Forget.lean index 276b8a31ddf0c9..5c868efcb13614 100644 --- a/Mathlib/CategoryTheory/ConcreteCategory/Forget.lean +++ b/Mathlib/CategoryTheory/ConcreteCategory/Forget.lean @@ -40,6 +40,8 @@ related work. namespace CategoryTheory +open TypeCat + universe w u variable (C : Type*) [Category* C] {FC : outParam <| C → C → Type*} {CC : outParam <| C → Type w} diff --git a/Mathlib/CategoryTheory/Types/Basic.lean b/Mathlib/CategoryTheory/Types/Basic.lean index d952bf512e991f..c26865c4915633 100644 --- a/Mathlib/CategoryTheory/Types/Basic.lean +++ b/Mathlib/CategoryTheory/Types/Basic.lean @@ -76,7 +76,7 @@ def Fun.id (X : Type*) : Fun X X := Fun.mk _root_.id /-- Composition of `Fun`s. -/ @[simps! +dsimpLhs] -def Fun.comp {X Y Z : Type*} (g : Fun X Y) (f : Fun Y Z) : Fun X Z := mk (f.toFun ∘ g.toFun) +def Fun.comp {X Y Z : Type*} (f : Fun Y Z) (g : Fun X Y) : Fun X Z := mk (f.toFun ∘ g.toFun) /-- The equivalence between `Fun`s and functions between types. -/ def Fun.homEquiv (X Y : Type u) : (Fun X Y) ≃ (X → Y) where @@ -87,7 +87,7 @@ def Fun.homEquiv (X Y : Type u) : (Fun X Y) ≃ (X → Y) where open CategoryTheory -mk_concrete_category (Type u) Fun (Fun.id) (Fun.comp) +mk_concrete_category (Type u) Fun (Fun.id) (Fun.comp) without_hom_equiv end TypeCat diff --git a/Mathlib/CategoryTheory/Yoneda.lean b/Mathlib/CategoryTheory/Yoneda.lean index 860cbafe48136d..cc020643fffeee 100644 --- a/Mathlib/CategoryTheory/Yoneda.lean +++ b/Mathlib/CategoryTheory/Yoneda.lean @@ -838,7 +838,7 @@ def yonedaLemma : yonedaPairing C ≅ yonedaEvaluation C := (by intro (X, F) (Y, G) f ext (a : yoneda.obj X.unop ⟶ F) apply ULift.ext - dsimp [yonedaEvaluation, yonedaEquiv] + dsimp [yonedaEvaluation, yonedaEquiv, -TypeCat.hom_comp] simp [← NatTrans.naturality_apply]) variable {C} @@ -1254,7 +1254,7 @@ def Functor.sectionsEquivHom (F : C ⥤ Type u₂) (X : Type u₂) [Unique X] : naturality _ _ _ := by ext x; simp } invFun τ := by refine ⟨fun j ↦ τ.app _ (default : X), fun φ ↦ ?_⟩ - simp [-const_obj_obj, ← comp_apply, -types_comp_apply, ← NatTrans.naturality] + simp [-const_obj_obj, ← comp_apply, ← NatTrans.naturality, -TypeCat.hom_comp] rfl right_inv τ := by ext _ (x : X) diff --git a/Mathlib/Tactic/CategoryTheory/MkConcreteCategory.lean b/Mathlib/Tactic/CategoryTheory/MkConcreteCategory.lean index d7596d40f5a1d6..fa9fc9f8c2bc71 100644 --- a/Mathlib/Tactic/CategoryTheory/MkConcreteCategory.lean +++ b/Mathlib/Tactic/CategoryTheory/MkConcreteCategory.lean @@ -23,6 +23,36 @@ open CategoryTheory namespace Mathlib.Tactic.CategoryTheory +private meta partial def containsCDot : Syntax → Bool + | .node _ k args => k == ``Lean.Parser.Term.cdot || args.any containsCDot + | _ => false + +private meta partial def replaceCDots (repls : Array Syntax) : Syntax → StateT Nat MacroM Syntax + | .node info k args => do + if k == ``Lean.Parser.Term.cdot then + let i ← get + modify (· + 1) + if h : i < repls.size then + pure repls[i] + else + Macro.throwError "too many placeholders in hom-family argument" + else + return .node info k (← args.mapM (replaceCDots repls)) + | stx => pure stx + +private meta def explicitHomFamilyLambda (cat FC : Term) : MacroM Term := do + let X := mkIdentFrom FC.raw `X + let Y := mkIdentFrom FC.raw `Y + let body ← (replaceCDots #[X, Y] FC.raw).run' 0 + let bodyTerm : Term := ⟨body⟩ + `(fun $X:ident $Y:ident : ($cat:term) => ($bodyTerm:term)) + +private meta def homFamilyApp (FC X Y : Term) : MacroM Term := do + if containsCDot FC.raw then + return ⟨← (replaceCDots #[X.raw, Y.raw] FC.raw).run' 0⟩ + else + `(($FC:term) $X $Y) + /-- `mk_concrete_category C FC id comp` generates the standard boilerplate for a concrete category on `C` whose underlying bundled hom type is `FC : C → C → Type*`, with identities given by `id` and @@ -32,13 +62,48 @@ The command is intended to be used in the namespace of `C`. It creates declarati `Hom.hom`, `ofHom`, `hom_id`, `hom_comp`, `hom_ofHom`, and `ofHom_hom`. -/ syntax (name := mkConcreteCategory) "mk_concrete_category " term:max ppSpace term:max ppSpace - term:max ppSpace term:max : command + term:max ppSpace term:max (ppSpace "without_hom_equiv")? : command /-- Elaborator for `mk_concrete_category`. -/ @[command_elab mkConcreteCategory] public meta def elabMkConcreteCategory : CommandElab := fun stx => do - let `(mk_concrete_category $cat $FC $idTerm $compTerm) := stx + let `(mk_concrete_category $cat $FC $idTerm $compTerm $[without_hom_equiv]?) := stx | throwUnsupportedSyntax + let genHomEquiv := stx[5].isNone + let FCFam ← + if containsCDot FC.raw then + liftMacroM <| explicitHomFamilyLambda cat FC + else + pure FC + let X : Term := mkIdent `X + let Y : Term := mkIdent `Y + let Z : Term := mkIdent `Z + let FCXX ← liftMacroM <| homFamilyApp FC X X + let FCXY ← liftMacroM <| homFamilyApp FC X Y + let FCYZ ← liftMacroM <| homFamilyApp FC Y Z + let FCXZ ← liftMacroM <| homFamilyApp FC X Z + let idFam ← `(($idTerm:term : ∀ X : $cat, $FCFam X X)) + let compFam ← `(($compTerm:term : ∀ {X Y Z : $cat} (g : $FCFam Y Z) (f : $FCFam X Y), + $FCFam X Z)) + + -- Check the expected shape of the arguments before generating declarations, so errors are + -- reported at the command invocation rather than inside the generated code. + -- elabCommand <| ← set_option hygiene false in `(command| + -- example : Sort _ := $cat) + + -- elabCommand <| ← set_option hygiene false in `(command| + -- example : ∀ X Y : $cat, Sort _ := ($FCFam:term)) + + -- elabCommand <| ← set_option hygiene false in `(command| + -- example : ∀ X : $cat, ($FCFam:term) X X := + -- fun X => ($idFam:term) X) + + -- elabCommand <| ← set_option hygiene false in `(command| + -- example : ∀ {X Y Z : $cat}, + -- ($FCFam:term) Y Z → + -- ($FCFam:term) X Y → + -- ($FCFam:term) X Z := + -- fun {X Y Z} g f => ($compFam:term) g f) elabCommand <| ← set_option hygiene false in `(command| set_option backward.privateInPublic true in @@ -47,38 +112,40 @@ public meta def elabMkConcreteCategory : CommandElab := fun stx => do structure Hom (X Y : $cat) where private mk :: /-- The underlying bundled morphism. -/ - hom' : ($FC:term) X Y) + hom' : $FCXY) elabCommand <| ← set_option hygiene false in `(command| set_option backward.privateInPublic true in set_option backward.privateInPublic.warn false in instance : CategoryTheory.Category $cat where Hom X Y := Hom X Y - id X := ⟨($idTerm:term) X⟩ - comp f g := ⟨($compTerm:term) f.hom' g.hom'⟩) + id X := ⟨($idFam:term) X⟩ + comp f g := ⟨($compFam:term) g.hom' f.hom'⟩) elabCommand <| ← set_option hygiene false in `(command| set_option backward.privateInPublic true in set_option backward.privateInPublic.warn false in - instance : CategoryTheory.ConcreteCategory $cat $FC where + instance : CategoryTheory.ConcreteCategory $cat $FCFam where hom := Hom.hom' ofHom := Hom.mk + hom_ofHom := by intros; rfl + ofHom_hom := by intros; rfl id_apply := by intros; rfl comp_apply := by intros; rfl) elabCommand <| ← set_option hygiene false in `(command| /-- Turn a categorical morphism back into its underlying bundled morphism. -/ - abbrev Hom.hom {X Y : $cat} (f : Hom X Y) := - CategoryTheory.ConcreteCategory.hom (C := $cat) f) + abbrev Hom.hom {X Y : $cat} (f : Hom X Y) : $FCXY := + CategoryTheory.ConcreteCategory.hom (C := $cat) (FC := $FCFam) f) elabCommand <| ← set_option hygiene false in `(command| /-- Typecheck a bundled morphism as a morphism in this concrete category. -/ - abbrev ofHom {X Y : $cat} (f : CategoryTheory.ToHom X Y) : X ⟶ Y := - CategoryTheory.ConcreteCategory.ofHom (C := $cat) f) + abbrev ofHom {X Y : $cat} (f : $FCXY) : X ⟶ Y := + CategoryTheory.ConcreteCategory.ofHom (C := $cat) (FC := $FCFam) f) elabCommand <| ← set_option hygiene false in `(command| /-- Use the `ConcreteCategory.hom` projection for `@[simps]` lemmas. -/ - def Hom.Simps.hom (X Y : $cat) (f : Hom X Y) := + def Hom.Simps.hom (X Y : $cat) (f : Hom X Y) : $FCXY := f.hom) elabCommand <| ← set_option hygiene false in `(command| @@ -86,18 +153,18 @@ public meta def elabMkConcreteCategory : CommandElab := fun stx => do elabCommand <| ← set_option hygiene false in `(command| @[simp] - lemma hom_id {X : $cat} : (𝟙 X : X ⟶ X).hom = (($idTerm) X) := + lemma hom_id {X : $cat} : (𝟙 X : X ⟶ X).hom = (($idFam) X) := rfl) elabCommand <| ← set_option hygiene false in `(command| @[simp] lemma hom_comp {X Y Z : $cat} (f : X ⟶ Y) (g : Y ⟶ Z) : - (f ≫ g).hom = (($compTerm) f.hom g.hom) := + (f ≫ g).hom = dsimp% (($compFam) g.hom f.hom) := rfl) elabCommand <| ← set_option hygiene false in `(command| @[simp] - lemma hom_ofHom {X Y : $cat} (f : CategoryTheory.ToHom X Y) : (ofHom f).hom = f := + lemma hom_ofHom {X Y : $cat} (f : $FCXY) : (ofHom f).hom = f := rfl) elabCommand <| ← set_option hygiene false in `(command| @@ -105,4 +172,28 @@ public meta def elabMkConcreteCategory : CommandElab := fun stx => do lemma ofHom_hom {X Y : $cat} (f : X ⟶ Y) : ofHom f.hom = f := rfl) + if genHomEquiv then + elabCommand <| ← set_option hygiene false in `(command| + /-- `Hom.hom` bundled as an `Equiv`. -/ + def homEquiv {X Y : $cat} : (X ⟶ Y) ≃ $FCXY where + toFun := Hom.hom + invFun := ofHom + left_inv _ := rfl + right_inv _ := rfl) + + elabCommand <| ← set_option hygiene false in `(command| + lemma hom_bijective {X Y : $cat} : + Function.Bijective (Hom.hom : (X ⟶ Y) → $FCXY) := + homEquiv.bijective) + + elabCommand <| ← set_option hygiene false in `(command| + lemma hom_injective {X Y : $cat} : + Function.Injective (Hom.hom : (X ⟶ Y) → $FCXY) := + hom_bijective.injective) + + elabCommand <| ← set_option hygiene false in `(command| + lemma hom_surjective {X Y : $cat} : + Function.Surjective (Hom.hom : (X ⟶ Y) → $FCXY) := + hom_bijective.surjective) + end Mathlib.Tactic.CategoryTheory diff --git a/MathlibTest/MkConcreteCategory.lean b/MathlibTest/MkConcreteCategory.lean index 417fc1e516e57f..1a005304d666b0 100644 --- a/MathlibTest/MkConcreteCategory.lean +++ b/MathlibTest/MkConcreteCategory.lean @@ -29,7 +29,7 @@ instance (X Y : TestCat.{u}) : FunLike (Fun X Y) X.α Y.α where protected def Fun.id (X : TestCat.{u}) : Fun X X where toFun := id -protected def Fun.comp {X Y Z : TestCat.{u}} (f : Fun X Y) (g : Fun Y Z) : Fun X Z where +protected def Fun.comp {X Y Z : TestCat.{u}} (g : Fun Y Z) (f : Fun X Y) : Fun X Z where toFun := g.toFun ∘ f.toFun mk_concrete_category TestCat Fun (Fun.id) (Fun.comp) @@ -62,7 +62,7 @@ mk_concrete_category TestCat Fun (Fun.id) (Fun.comp) #guard_msgs in #check Hom.hom -/-- info: TestCat.ofHom.{u_1} {X Y : TestCat} (f : ToHom X Y) : X ⟶ Y -/ +/-- info: TestCat.ofHom.{u_1} {X Y : TestCat} (f : X.Fun Y) : X ⟶ Y -/ #guard_msgs in #check ofHom @@ -74,11 +74,12 @@ mk_concrete_category TestCat Fun (Fun.id) (Fun.comp) #guard_msgs in #check hom_id -/-- info: TestCat.hom_comp.{u_1} {X Y Z : TestCat} (f : X ⟶ Y) (g : Y ⟶ Z) : Hom.hom (f ≫ g) = (Hom.hom f).comp (Hom.hom g) -/ +/-- info: TestCat.hom_comp.{u_1} {X Y Z : TestCat} (f : X ⟶ Y) (g : Y ⟶ Z) : + Hom.hom (f ≫ g) = (fun {X Y Z} => Fun.comp) (Hom.hom g) (Hom.hom f) -/ #guard_msgs in #check hom_comp -/-- info: TestCat.hom_ofHom.{u_1} {X Y : TestCat} (f : ToHom X Y) : Hom.hom (ofHom f) = f -/ +/-- info: TestCat.hom_ofHom.{u_1} {X Y : TestCat} (f : X.Fun Y) : Hom.hom (ofHom f) = f -/ #guard_msgs in #check hom_ofHom @@ -102,7 +103,7 @@ example {X : TestCat} : (𝟙 X : X ⟶ X).hom = Fun.id X := by dsimp example {X Y Z : TestCat} (f : X ⟶ Y) (g : Y ⟶ Z) : - (f ≫ g).hom = Fun.comp f.hom g.hom := by + (f ≫ g).hom = Fun.comp g.hom f.hom := by dsimp example {X Y : TestCat} (f g : X ⟶ Y) (h : f.hom = g.hom) : f = g :=