fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
Zag (j₁ j₂ : J) : Prop :=
Nonempty (j₁ ⟶ j₂) ∨ Nonempty (j₂ ⟶ j₁)
@[refl] theorem Zag.refl (X : J) : Zag X X := Or.inl ⟨𝟙 _⟩ | def | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zag | j₁ and j₂ are related by `Zag` if there is a morphism between them. |
zag_symmetric : Symmetric (@Zag J _) := fun _ _ h => h.symm
@[symm] theorem Zag.symm {j₁ j₂ : J} (h : Zag j₁ j₂) : Zag j₂ j₁ := zag_symmetric h | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | zag_symmetric | null |
Zag.of_hom {j₁ j₂ : J} (f : j₁ ⟶ j₂) : Zag j₁ j₂ := Or.inl ⟨f⟩ | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zag.of_hom | null |
Zag.of_inv {j₁ j₂ : J} (f : j₂ ⟶ j₁) : Zag j₁ j₂ := Or.inr ⟨f⟩ | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zag.of_inv | null |
Zigzag : J → J → Prop :=
Relation.ReflTransGen Zag | def | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zigzag | `j₁` and `j₂` are related by `Zigzag` if there is a chain of
morphisms from `j₁` to `j₂`, with backward morphisms allowed. |
zigzag_symmetric : Symmetric (@Zigzag J _) :=
Relation.ReflTransGen.symmetric zag_symmetric | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | zigzag_symmetric | null |
zigzag_equivalence : _root_.Equivalence (@Zigzag J _) :=
_root_.Equivalence.mk Relation.reflexive_reflTransGen (fun h => zigzag_symmetric h)
(fun h g => Relation.transitive_reflTransGen h g)
@[refl] theorem Zigzag.refl (X : J) : Zigzag X X := zigzag_equivalence.refl _
@[symm] theorem Zigzag.symm {j₁ j₂ : J} (h : Zigzag j₁ j₂) : Zigzag j₂ j₁ := zigzag_symmetric h
@[trans] theorem Zigzag.trans {j₁ j₂ j₃ : J} (h₁ : Zigzag j₁ j₂) (h₂ : Zigzag j₂ j₃) :
Zigzag j₁ j₃ :=
zigzag_equivalence.trans h₁ h₂ | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | zigzag_equivalence | null |
Zigzag.of_zag {j₁ j₂ : J} (h : Zag j₁ j₂) : Zigzag j₁ j₂ :=
Relation.ReflTransGen.single h | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zigzag.of_zag | null |
Zigzag.of_hom {j₁ j₂ : J} (f : j₁ ⟶ j₂) : Zigzag j₁ j₂ :=
of_zag (Zag.of_hom f) | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zigzag.of_hom | null |
Zigzag.of_inv {j₁ j₂ : J} (f : j₂ ⟶ j₁) : Zigzag j₁ j₂ :=
of_zag (Zag.of_inv f) | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zigzag.of_inv | null |
Zigzag.of_zag_trans {j₁ j₂ j₃ : J} (h₁ : Zag j₁ j₂) (h₂ : Zag j₂ j₃) : Zigzag j₁ j₃ :=
trans (of_zag h₁) (of_zag h₂) | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zigzag.of_zag_trans | null |
Zigzag.of_hom_hom {j₁ j₂ j₃ : J} (f₁₂ : j₁ ⟶ j₂) (f₂₃ : j₂ ⟶ j₃) : Zigzag j₁ j₃ :=
(of_hom f₁₂).trans (of_hom f₂₃) | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zigzag.of_hom_hom | null |
Zigzag.of_hom_inv {j₁ j₂ j₃ : J} (f₁₂ : j₁ ⟶ j₂) (f₃₂ : j₃ ⟶ j₂) : Zigzag j₁ j₃ :=
(of_hom f₁₂).trans (of_inv f₃₂) | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zigzag.of_hom_inv | null |
Zigzag.of_inv_hom {j₁ j₂ j₃ : J} (f₂₁ : j₂ ⟶ j₁) (f₂₃ : j₂ ⟶ j₃) : Zigzag j₁ j₃ :=
(of_inv f₂₁).trans (of_hom f₂₃) | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zigzag.of_inv_hom | null |
Zigzag.of_inv_inv {j₁ j₂ j₃ : J} (f₂₁ : j₂ ⟶ j₁) (f₃₂ : j₃ ⟶ j₂) : Zigzag j₁ j₃ :=
(of_inv f₂₁).trans (of_inv f₃₂) | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zigzag.of_inv_inv | null |
Zigzag.setoid (J : Type u₂) [Category.{v₁} J] : Setoid J where
r := Zigzag
iseqv := zigzag_equivalence | def | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | Zigzag.setoid | The setoid given by the equivalence relation `Zigzag`. A quotient for this
setoid is a connected component of the category. |
zigzag_prefunctor_obj_of_zigzag (F : J ⥤q K) {j₁ j₂ : J} (h : Zigzag j₁ j₂) :
Zigzag (F.obj j₁) (F.obj j₂) :=
h.lift _ fun _ _ => Or.imp (Nonempty.map fun f => F.map f) (Nonempty.map fun f => F.map f) | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | zigzag_prefunctor_obj_of_zigzag | If there is a zigzag from `j₁` to `j₂`, then there is a zigzag from `F j₁` to
`F j₂` as long as `F` is a prefunctor. |
zigzag_obj_of_zigzag (F : J ⥤ K) {j₁ j₂ : J} (h : Zigzag j₁ j₂) :
Zigzag (F.obj j₁) (F.obj j₂) :=
zigzag_prefunctor_obj_of_zigzag F.toPrefunctor h | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | zigzag_obj_of_zigzag | If there is a zigzag from `j₁` to `j₂`, then there is a zigzag from `F j₁` to
`F j₂` as long as `F` is a functor. |
eq_of_zag (X) {a b : Discrete X} (h : Zag a b) : a.as = b.as :=
h.elim (fun ⟨f⟩ ↦ Discrete.eq_of_hom f) (fun ⟨f⟩ ↦ (Discrete.eq_of_hom f).symm) | lemma | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | eq_of_zag | A Zag in a discrete category entails an equality of its extremities |
eq_of_zigzag (X) {a b : Discrete X} (h : Zigzag a b) : a.as = b.as := by
induction h with
| refl => rfl
| tail _ h eq => exact eq.trans (eq_of_zag _ h) | lemma | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | eq_of_zigzag | A zigzag in a discrete category entails an equality of its extremities |
zag_of_zag_obj (F : J ⥤ K) [F.Full] {j₁ j₂ : J} (h : Zag (F.obj j₁) (F.obj j₂)) :
Zag j₁ j₂ :=
Or.imp (Nonempty.map F.preimage) (Nonempty.map F.preimage) h | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | zag_of_zag_obj | null |
equiv_relation [IsPreconnected J] (r : J → J → Prop) (hr : _root_.Equivalence r)
(h : ∀ {j₁ j₂ : J} (_ : j₁ ⟶ j₂), r j₁ j₂) : ∀ j₁ j₂ : J, r j₁ j₂ := by
intro j₁ j₂
have z : ∀ j : J, r j₁ j :=
induct_on_objects {k | r j₁ k} (hr.1 j₁)
fun f => ⟨fun t => hr.3 t (h f), fun t => hr.3 t (hr.2 (h f))⟩
exact z j₂ | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | equiv_relation | Any equivalence relation containing (⟶) holds for all pairs of a connected category. |
isPreconnected_zigzag [IsPreconnected J] (j₁ j₂ : J) : Zigzag j₁ j₂ :=
equiv_relation _ zigzag_equivalence
(fun f => Relation.ReflTransGen.single (Or.inl (Nonempty.intro f))) _ _ | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | isPreconnected_zigzag | In a connected category, any two objects are related by `Zigzag`. |
zigzag_isPreconnected (h : ∀ j₁ j₂ : J, Zigzag j₁ j₂) : IsPreconnected J := by
apply IsPreconnected.of_constant_of_preserves_morphisms
intro α F hF j j'
specialize h j j'
induction h with
| refl => rfl
| tail _ hj ih =>
rw [ih]
rcases hj with (⟨⟨hj⟩⟩|⟨⟨hj⟩⟩)
exacts [hF hj, (hF hj).symm] | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | zigzag_isPreconnected | null |
zigzag_isConnected [Nonempty J] (h : ∀ j₁ j₂ : J, Zigzag j₁ j₂) : IsConnected J :=
{ zigzag_isPreconnected h with } | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | zigzag_isConnected | If any two objects in a nonempty category are related by `Zigzag`, the category is connected. |
exists_zigzag' [IsConnected J] (j₁ j₂ : J) :
∃ l, List.IsChain Zag (j₁ :: l) ∧ List.getLast (j₁ :: l) (List.cons_ne_nil _ _) = j₂ :=
List.exists_isChain_cons_of_relationReflTransGen (isPreconnected_zigzag _ _) | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | exists_zigzag' | null |
isPreconnected_of_zigzag (h : ∀ j₁ j₂ : J, ∃ l,
List.IsChain Zag (j₁ :: l) ∧ List.getLast (j₁ :: l) (List.cons_ne_nil _ _) = j₂) :
IsPreconnected J := by
apply zigzag_isPreconnected
intro j₁ j₂
rcases h j₁ j₂ with ⟨l, hl₁, hl₂⟩
apply List.relationReflTransGen_of_exists_isChain_cons l hl₁ hl₂ | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | isPreconnected_of_zigzag | If any two objects in a nonempty category are linked by a sequence of (potentially reversed)
morphisms, then J is connected.
The converse of `exists_zigzag'`. |
isConnected_of_zigzag [Nonempty J] (h : ∀ j₁ j₂ : J, ∃ l,
List.IsChain Zag (j₁ :: l) ∧ List.getLast (j₁ :: l) (List.cons_ne_nil _ _) = j₂) :
IsConnected J :=
{ isPreconnected_of_zigzag h with } | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | isConnected_of_zigzag | If any two objects in a nonempty category are linked by a sequence of (potentially reversed)
morphisms, then J is connected.
The converse of `exists_zigzag'`. |
discreteIsConnectedEquivPUnit {α : Type u₁} [IsConnected (Discrete α)] : α ≃ PUnit :=
Discrete.equivOfEquivalence.{u₁, u₁}
{ functor := Functor.star (Discrete α)
inverse := Discrete.functor fun _ => Classical.arbitrary _
unitIso := isoConstant _ (Classical.arbitrary _)
counitIso := Functor.punitExt _ _ }
variable {C : Type w₂} [Category.{w₁} C] | def | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | discreteIsConnectedEquivPUnit | If `Discrete α` is connected, then `α` is (type-)equivalent to `PUnit`. |
nat_trans_from_is_connected [IsPreconnected J] {X Y : C}
(α : (Functor.const J).obj X ⟶ (Functor.const J).obj Y) :
∀ j j' : J, α.app j = (α.app j' : X ⟶ Y) :=
@constant_of_preserves_morphisms _ _ _ (X ⟶ Y) (fun j => α.app j) fun _ _ f => by
simpa using (α.naturality f).symm | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | nat_trans_from_is_connected | For objects `X Y : C`, any natural transformation `α : const X ⟶ const Y` from a connected
category must be constant.
This is the key property of connected categories which we use to establish properties about limits. |
nonempty_hom_of_preconnected_groupoid {G} [Groupoid G] [IsPreconnected G] :
∀ x y : G, Nonempty (x ⟶ y) := by
refine equiv_relation _ ?_ fun {j₁ j₂} => Nonempty.intro
exact
⟨fun j => ⟨𝟙 _⟩,
fun {j₁ j₂} => Nonempty.map fun f => inv f,
fun {_ _ _} => Nonempty.map2 (· ≫ ·)⟩
attribute [instance] nonempty_hom_of_preconnected_groupoid | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | nonempty_hom_of_preconnected_groupoid | null |
isPreconnected_of_subsingleton [Subsingleton J] : IsPreconnected J where
iso_constant {α} F j := ⟨NatIso.ofComponents (fun x ↦ eqToIso (by simp [Subsingleton.allEq x j]))⟩ | instance | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | isPreconnected_of_subsingleton | null |
isConnected_of_nonempty_and_subsingleton [Nonempty J] [Subsingleton J] :
IsConnected J where | instance | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.PUnit",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Category.ULift"
] | Mathlib/CategoryTheory/IsConnected.lean | isConnected_of_nonempty_and_subsingleton | null |
@[stacks 0017]
Iso {C : Type u} [Category.{v} C] (X Y : C) where
/-- The forward direction of an isomorphism. -/
hom : X ⟶ Y
/-- The backwards direction of an isomorphism. -/
inv : Y ⟶ X
/-- Composition of the two directions of an isomorphism is the identity on the source. -/
hom_inv_id : hom ≫ inv = 𝟙 X := by cat_disch
/-- Composition of the two directions of an isomorphism in reverse order
is the identity on the target. -/
inv_hom_id : inv ≫ hom = 𝟙 Y := by cat_disch
attribute [reassoc (attr := simp), grind =] Iso.hom_inv_id Iso.inv_hom_id | structure | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | Iso | An isomorphism (a.k.a. an invertible morphism) between two objects of a category.
The inverse morphism is bundled.
See also `CategoryTheory.Core` for the category with the same objects and isomorphisms playing
the role of morphisms. |
@[symm]
symm (I : X ≅ Y) : Y ≅ X where
hom := I.inv
inv := I.hom
@[simp, grind =] | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | symm | Notation for an isomorphism in a category. -/
infixr:10 " ≅ " => Iso -- type as \cong or \iso
variable {C : Type u} [Category.{v} C] {X Y Z : C}
namespace Iso
@[ext, grind ext]
theorem ext ⦃α β : X ≅ Y⦄ (w : α.hom = β.hom) : α = β :=
suffices α.inv = β.inv by grind [Iso]
calc
α.inv = α.inv ≫ β.hom ≫ β.inv := by grind
_ = β.inv := by grind
/-- Inverse isomorphism. |
symm_hom (α : X ≅ Y) : α.symm.hom = α.inv :=
rfl
@[simp, grind =] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | symm_hom | null |
symm_inv (α : X ≅ Y) : α.symm.inv = α.hom :=
rfl
@[simp, grind =] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | symm_inv | null |
symm_mk {X Y : C} (hom : X ⟶ Y) (inv : Y ⟶ X) (hom_inv_id) (inv_hom_id) :
Iso.symm { hom, inv, hom_inv_id := hom_inv_id, inv_hom_id := inv_hom_id } =
{ hom := inv, inv := hom, hom_inv_id := inv_hom_id, inv_hom_id := hom_inv_id } :=
rfl
@[simp, grind =] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | symm_mk | null |
symm_symm_eq {X Y : C} (α : X ≅ Y) : α.symm.symm = α := rfl | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | symm_symm_eq | null |
symm_bijective {X Y : C} : Function.Bijective (symm : (X ≅ Y) → _) :=
Function.bijective_iff_has_inverse.mpr ⟨_, symm_symm_eq, symm_symm_eq⟩
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | symm_bijective | null |
symm_eq_iff {X Y : C} {α β : X ≅ Y} : α.symm = β.symm ↔ α = β :=
symm_bijective.injective.eq_iff | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | symm_eq_iff | null |
nonempty_iso_symm (X Y : C) : Nonempty (X ≅ Y) ↔ Nonempty (Y ≅ X) :=
⟨fun h => ⟨h.some.symm⟩, fun h => ⟨h.some.symm⟩⟩ | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | nonempty_iso_symm | null |
@[refl, simps (attr := grind =)]
refl (X : C) : X ≅ X where
hom := 𝟙 X
inv := 𝟙 X | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | refl | Identity isomorphism. |
nonempty_iso_refl (X : C) : Nonempty (X ≅ X) := ⟨default⟩
@[simp, grind =] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | nonempty_iso_refl | null |
refl_symm (X : C) : (Iso.refl X).symm = Iso.refl X := rfl | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | refl_symm | null |
@[simps (attr := grind =)]
trans (α : X ≅ Y) (β : Y ≅ Z) : X ≅ Z where
hom := α.hom ≫ β.hom
inv := β.inv ≫ α.inv
@[simps] | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | trans | Composition of two isomorphisms |
instTransIso : Trans (α := C) (· ≅ ·) (· ≅ ·) (· ≅ ·) where
trans := trans | instance | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | instTransIso | null |
@[simps]
homToEquiv (α : X ≅ Y) {Z : C} : (Z ⟶ X) ≃ (Z ⟶ Y) where
toFun f := f ≫ α.hom
invFun g := g ≫ α.inv
left_inv := by cat_disch
right_inv := by cat_disch | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | homToEquiv | Notation for composition of isomorphisms. -/
infixr:80 " ≪≫ " => Iso.trans -- type as `\ll \gg`.
@[simp, grind =]
theorem trans_mk {X Y Z : C} (hom : X ⟶ Y) (inv : Y ⟶ X) (hom_inv_id) (inv_hom_id)
(hom' : Y ⟶ Z) (inv' : Z ⟶ Y) (hom_inv_id') (inv_hom_id') (hom_inv_id'') (inv_hom_id'') :
Iso.trans ⟨hom, inv, hom_inv_id, inv_hom_id⟩ ⟨hom', inv', hom_inv_id', inv_hom_id'⟩ =
⟨hom ≫ hom', inv' ≫ inv, hom_inv_id'', inv_hom_id''⟩ :=
rfl
@[simp, grind _=_]
theorem trans_symm (α : X ≅ Y) (β : Y ≅ Z) : (α ≪≫ β).symm = β.symm ≪≫ α.symm :=
rfl
@[simp, grind _=_]
theorem trans_assoc {Z' : C} (α : X ≅ Y) (β : Y ≅ Z) (γ : Z ≅ Z') :
(α ≪≫ β) ≪≫ γ = α ≪≫ β ≪≫ γ := by
ext; simp only [trans_hom, Category.assoc]
@[simp]
theorem refl_trans (α : X ≅ Y) : Iso.refl X ≪≫ α = α := by ext; apply Category.id_comp
@[simp]
theorem trans_refl (α : X ≅ Y) : α ≪≫ Iso.refl Y = α := by ext; apply Category.comp_id
@[simp]
theorem symm_self_id (α : X ≅ Y) : α.symm ≪≫ α = Iso.refl Y :=
ext α.inv_hom_id
@[simp]
theorem self_symm_id (α : X ≅ Y) : α ≪≫ α.symm = Iso.refl X :=
ext α.hom_inv_id
@[simp]
theorem symm_self_id_assoc (α : X ≅ Y) (β : Y ≅ Z) : α.symm ≪≫ α ≪≫ β = β := by
rw [← trans_assoc, symm_self_id, refl_trans]
@[simp]
theorem self_symm_id_assoc (α : X ≅ Y) (β : X ≅ Z) : α ≪≫ α.symm ≪≫ β = β := by
rw [← trans_assoc, self_symm_id, refl_trans]
theorem inv_comp_eq (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z} : α.inv ≫ f = g ↔ f = α.hom ≫ g :=
⟨fun H => by simp [H.symm], fun H => by simp [H]⟩
theorem eq_inv_comp (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z} : g = α.inv ≫ f ↔ α.hom ≫ g = f :=
(inv_comp_eq α.symm).symm
theorem comp_inv_eq (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X} : f ≫ α.inv = g ↔ f = g ≫ α.hom :=
⟨fun H => by simp [H.symm], fun H => by simp [H]⟩
theorem eq_comp_inv (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X} : g = f ≫ α.inv ↔ g ≫ α.hom = f :=
(comp_inv_eq α.symm).symm
theorem inv_eq_inv (f g : X ≅ Y) : f.inv = g.inv ↔ f.hom = g.hom :=
have : ∀ {X Y : C} (f g : X ≅ Y), f.hom = g.hom → f.inv = g.inv := fun f g h => by rw [ext h]
⟨this f.symm g.symm, this f g⟩
theorem hom_comp_eq_id (α : X ≅ Y) {f : Y ⟶ X} : α.hom ≫ f = 𝟙 X ↔ f = α.inv := by
rw [← eq_inv_comp, comp_id]
theorem comp_hom_eq_id (α : X ≅ Y) {f : Y ⟶ X} : f ≫ α.hom = 𝟙 Y ↔ f = α.inv := by
rw [← eq_comp_inv, id_comp]
theorem inv_comp_eq_id (α : X ≅ Y) {f : X ⟶ Y} : α.inv ≫ f = 𝟙 Y ↔ f = α.hom :=
hom_comp_eq_id α.symm
theorem comp_inv_eq_id (α : X ≅ Y) {f : X ⟶ Y} : f ≫ α.inv = 𝟙 X ↔ f = α.hom :=
comp_hom_eq_id α.symm
theorem hom_eq_inv (α : X ≅ Y) (β : Y ≅ X) : α.hom = β.inv ↔ β.hom = α.inv := by
rw [← symm_inv, inv_eq_inv α.symm β, eq_comm]
rfl
attribute [local grind] Function.LeftInverse Function.RightInverse
/-- The bijection `(Z ⟶ X) ≃ (Z ⟶ Y)` induced by `α : X ≅ Y`. |
@[simps]
homFromEquiv (α : X ≅ Y) {Z : C} : (X ⟶ Z) ≃ (Y ⟶ Z) where
toFun f := α.inv ≫ f
invFun g := α.hom ≫ g
left_inv := by cat_disch
right_inv := by cat_disch | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | homFromEquiv | The bijection `(X ⟶ Z) ≃ (Y ⟶ Z)` induced by `α : X ≅ Y`. |
IsIso (f : X ⟶ Y) : Prop where
/-- The existence of an inverse morphism. -/
out : ∃ inv : Y ⟶ X, f ≫ inv = 𝟙 X ∧ inv ≫ f = 𝟙 Y | class | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | IsIso | `IsIso` typeclass expressing that a morphism is invertible. |
noncomputable inv (f : X ⟶ Y) [I : IsIso f] : Y ⟶ X :=
Classical.choose I.1 | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv | The inverse of a morphism `f` when we have `[IsIso f]`. |
@[simp, grind =]
hom_inv_id (f : X ⟶ Y) [I : IsIso f] : f ≫ inv f = 𝟙 X :=
(Classical.choose_spec I.1).left
@[simp, grind =] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | hom_inv_id | null |
inv_hom_id (f : X ⟶ Y) [I : IsIso f] : inv f ≫ f = 𝟙 Y :=
(Classical.choose_spec I.1).right
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv_hom_id | null |
hom_inv_id_assoc (f : X ⟶ Y) [I : IsIso f] {Z} (g : X ⟶ Z) : f ≫ inv f ≫ g = g := by
simp [← Category.assoc]
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | hom_inv_id_assoc | null |
inv_hom_id_assoc (f : X ⟶ Y) [I : IsIso f] {Z} (g : Y ⟶ Z) : inv f ≫ f ≫ g = g := by
simp [← Category.assoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv_hom_id_assoc | null |
Iso.isIso_hom (e : X ≅ Y) : IsIso e.hom :=
⟨e.inv, by simp only [hom_inv_id], by simp⟩ | lemma | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | Iso.isIso_hom | null |
Iso.isIso_inv (e : X ≅ Y) : IsIso e.inv := e.symm.isIso_hom
attribute [instance] Iso.isIso_hom Iso.isIso_inv
open IsIso | lemma | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | Iso.isIso_inv | null |
noncomputable asIso (f : X ⟶ Y) [IsIso f] : X ≅ Y :=
⟨f, inv f, hom_inv_id f, inv_hom_id f⟩
@[simp] | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | asIso | Reinterpret a morphism `f` with an `IsIso f` instance as an `Iso`. |
asIso_hom (f : X ⟶ Y) [IsIso f] : (asIso f).hom = f :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | asIso_hom | null |
asIso_inv (f : X ⟶ Y) [IsIso f] : (asIso f).inv = inv f :=
rfl | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | asIso_inv | null |
inv_eq_of_hom_inv_id {f : X ⟶ Y} [IsIso f] {g : Y ⟶ X} (hom_inv_id : f ≫ g = 𝟙 X) :
inv f = g := by
have := congrArg (inv f ≫ ·) hom_inv_id
grind | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv_eq_of_hom_inv_id | null |
inv_eq_of_inv_hom_id {f : X ⟶ Y} [IsIso f] {g : Y ⟶ X} (inv_hom_id : g ≫ f = 𝟙 Y) :
inv f = g := by
have := congrArg (· ≫ inv f) inv_hom_id
grind
@[aesop apply safe (rule_sets := [CategoryTheory])] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv_eq_of_inv_hom_id | null |
eq_inv_of_hom_inv_id {f : X ⟶ Y} [IsIso f] {g : Y ⟶ X} (hom_inv_id : f ≫ g = 𝟙 X) :
g = inv f :=
(inv_eq_of_hom_inv_id hom_inv_id).symm | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | eq_inv_of_hom_inv_id | null |
eq_inv_of_inv_hom_id {f : X ⟶ Y} [IsIso f] {g : Y ⟶ X} (inv_hom_id : g ≫ f = 𝟙 Y) :
g = inv f :=
(inv_eq_of_inv_hom_id inv_hom_id).symm | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | eq_inv_of_inv_hom_id | null |
id (X : C) : IsIso (𝟙 X) := ⟨⟨𝟙 X, by simp⟩⟩
variable {f : X ⟶ Y} {h : Y ⟶ Z} | instance | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | id | null |
inv_isIso [IsIso f] : IsIso (inv f) :=
(asIso f).isIso_inv
/- The following instance has lower priority for the following reason:
Suppose we are given `f : X ≅ Y` with `X Y : Type u`.
Without the lower priority, typeclass inference cannot deduce `IsIso f.hom`
because `f.hom` is defeq to `(fun x ↦ x) ≫ f.hom`, triggering a loop. -/ | instance | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv_isIso | null |
comp_isIso' (_ : IsIso f) (_ : IsIso h) : IsIso (f ≫ h) := inferInstance
@[simp] | lemma | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | comp_isIso' | The composition of isomorphisms is an isomorphism. Here the arguments of type `IsIso` are
explicit, to make this easier to use with the `refine` tactic, for instance. |
inv_id : inv (𝟙 X) = 𝟙 X := by
apply inv_eq_of_hom_inv_id
simp
@[simp, reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv_id | null |
inv_comp [IsIso f] [IsIso h] : inv (f ≫ h) = inv h ≫ inv f := by
apply inv_eq_of_hom_inv_id
simp
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv_comp | null |
inv_inv [IsIso f] : inv (inv f) = f := by
apply inv_eq_of_hom_inv_id
simp
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv_inv | null |
Iso.inv_inv (f : X ≅ Y) : inv f.inv = f.hom := by
apply inv_eq_of_hom_inv_id
simp
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | Iso.inv_inv | null |
Iso.inv_hom (f : X ≅ Y) : inv f.hom = f.inv := by
apply inv_eq_of_hom_inv_id
simp
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | Iso.inv_hom | null |
inv_comp_eq (α : X ⟶ Y) [IsIso α] {f : X ⟶ Z} {g : Y ⟶ Z} : inv α ≫ f = g ↔ f = α ≫ g :=
(asIso α).inv_comp_eq
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv_comp_eq | null |
eq_inv_comp (α : X ⟶ Y) [IsIso α] {f : X ⟶ Z} {g : Y ⟶ Z} : g = inv α ≫ f ↔ α ≫ g = f :=
(asIso α).eq_inv_comp
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | eq_inv_comp | null |
comp_inv_eq (α : X ⟶ Y) [IsIso α] {f : Z ⟶ Y} {g : Z ⟶ X} : f ≫ inv α = g ↔ f = g ≫ α :=
(asIso α).comp_inv_eq
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | comp_inv_eq | null |
eq_comp_inv (α : X ⟶ Y) [IsIso α] {f : Z ⟶ Y} {g : Z ⟶ X} : g = f ≫ inv α ↔ g ≫ α = f :=
(asIso α).eq_comp_inv | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | eq_comp_inv | null |
of_isIso_comp_left {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] [IsIso (f ≫ g)] :
IsIso g := by
rw [← id_comp g, ← inv_hom_id f, assoc]
infer_instance | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | of_isIso_comp_left | null |
of_isIso_comp_right {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso g] [IsIso (f ≫ g)] :
IsIso f := by
rw [← comp_id f, ← hom_inv_id g, ← assoc]
infer_instance | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | of_isIso_comp_right | null |
of_isIso_fac_left {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z} [IsIso f]
[hh : IsIso h] (w : f ≫ g = h) : IsIso g := by
rw [← w] at hh
exact of_isIso_comp_left f g | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | of_isIso_fac_left | null |
of_isIso_fac_right {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z} [IsIso g]
[hh : IsIso h] (w : f ≫ g = h) : IsIso f := by
rw [← w] at hh
exact of_isIso_comp_right f g | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | of_isIso_fac_right | null |
eq_of_inv_eq_inv {f g : X ⟶ Y} [IsIso f] [IsIso g] (p : inv f = inv g) : f = g := by
apply (cancel_epi (inv f)).1
rw [inv_hom_id, p, inv_hom_id] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | eq_of_inv_eq_inv | null |
IsIso.inv_eq_inv {f g : X ⟶ Y} [IsIso f] [IsIso g] : inv f = inv g ↔ f = g :=
Iso.inv_eq_inv (asIso f) (asIso g) | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | IsIso.inv_eq_inv | null |
hom_comp_eq_id (g : X ⟶ Y) [IsIso g] {f : Y ⟶ X} : g ≫ f = 𝟙 X ↔ f = inv g :=
(asIso g).hom_comp_eq_id | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | hom_comp_eq_id | null |
comp_hom_eq_id (g : X ⟶ Y) [IsIso g] {f : Y ⟶ X} : f ≫ g = 𝟙 Y ↔ f = inv g :=
(asIso g).comp_hom_eq_id | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | comp_hom_eq_id | null |
inv_comp_eq_id (g : X ⟶ Y) [IsIso g] {f : X ⟶ Y} : inv g ≫ f = 𝟙 Y ↔ f = g :=
(asIso g).inv_comp_eq_id | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv_comp_eq_id | null |
comp_inv_eq_id (g : X ⟶ Y) [IsIso g] {f : X ⟶ Y} : f ≫ inv g = 𝟙 X ↔ f = g :=
(asIso g).comp_inv_eq_id | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | comp_inv_eq_id | null |
isIso_of_hom_comp_eq_id (g : X ⟶ Y) [IsIso g] {f : Y ⟶ X} (h : g ≫ f = 𝟙 X) : IsIso f := by
rw [(hom_comp_eq_id _).mp h]
infer_instance | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | isIso_of_hom_comp_eq_id | null |
isIso_of_comp_hom_eq_id (g : X ⟶ Y) [IsIso g] {f : Y ⟶ X} (h : f ≫ g = 𝟙 Y) : IsIso f := by
rw [(comp_hom_eq_id _).mp h]
infer_instance | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | isIso_of_comp_hom_eq_id | null |
inv_ext {f : X ≅ Y} {g : Y ⟶ X} (hom_inv_id : f.hom ≫ g = 𝟙 X) : f.inv = g :=
((hom_comp_eq_id f).1 hom_inv_id).symm
@[aesop apply safe (rule_sets := [CategoryTheory])] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv_ext | null |
inv_ext' {f : X ≅ Y} {g : Y ⟶ X} (hom_inv_id : f.hom ≫ g = 𝟙 X) : g = f.inv :=
(hom_comp_eq_id f).1 hom_inv_id
/-!
All these cancellation lemmas can be solved by `simp [cancel_mono]` (or `simp [cancel_epi]`),
but with the current design `cancel_mono` is not a good `simp` lemma,
because it generates a typeclass search.
When we can see syntactically that a morphism is a `mono` or an `epi`
because it came from an isomorphism, it's fine to do the cancellation via `simp`.
In the longer term, it might be worth exploring making `mono` and `epi` structures,
rather than typeclasses, with coercions back to `X ⟶ Y`.
Presumably we could write `X ↪ Y` and `X ↠ Y`.
-/
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | inv_ext' | null |
cancel_iso_hom_left {X Y Z : C} (f : X ≅ Y) (g g' : Y ⟶ Z) :
f.hom ≫ g = f.hom ≫ g' ↔ g = g' := by
simp only [cancel_epi]
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | cancel_iso_hom_left | null |
cancel_iso_inv_left {X Y Z : C} (f : Y ≅ X) (g g' : Y ⟶ Z) :
f.inv ≫ g = f.inv ≫ g' ↔ g = g' := by
simp only [cancel_epi]
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | cancel_iso_inv_left | null |
cancel_iso_hom_right {X Y Z : C} (f f' : X ⟶ Y) (g : Y ≅ Z) :
f ≫ g.hom = f' ≫ g.hom ↔ f = f' := by
simp only [cancel_mono]
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | cancel_iso_hom_right | null |
cancel_iso_inv_right {X Y Z : C} (f f' : X ⟶ Y) (g : Z ≅ Y) :
f ≫ g.inv = f' ≫ g.inv ↔ f = f' := by
simp only [cancel_mono]
/-
Unfortunately cancelling an isomorphism from the right of a chain of compositions is awkward.
We would need separate lemmas for each chain length (worse: for each pair of chain lengths).
We provide two more lemmas, for case of three morphisms, because this actually comes up in practice,
but then stop.
-/
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | cancel_iso_inv_right | null |
cancel_iso_hom_right_assoc {W X X' Y Z : C} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X')
(g' : X' ⟶ Y) (h : Y ≅ Z) : f ≫ g ≫ h.hom = f' ≫ g' ≫ h.hom ↔ f ≫ g = f' ≫ g' := by
simp only [← Category.assoc, cancel_mono]
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | cancel_iso_hom_right_assoc | null |
cancel_iso_inv_right_assoc {W X X' Y Z : C} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X')
(g' : X' ⟶ Y) (h : Z ≅ Y) : f ≫ g ≫ h.inv = f' ≫ g' ≫ h.inv ↔ f ≫ g = f' ≫ g' := by
simp only [← Category.assoc, cancel_mono] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | cancel_iso_inv_right_assoc | null |
@[reassoc (attr := simp), grind =]
map_hom_inv_id (F : C ⥤ D) :
F.map e.hom ≫ F.map e.inv = 𝟙 _ := by grind
@[reassoc (attr := simp), grind =] | lemma | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | map_hom_inv_id | null |
map_inv_hom_id (F : C ⥤ D) :
F.map e.inv ≫ F.map e.hom = 𝟙 _ := by grind | lemma | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | map_inv_hom_id | null |
@[simps]
mapIso (F : C ⥤ D) {X Y : C} (i : X ≅ Y) : F.obj X ≅ F.obj Y where
hom := F.map i.hom
inv := F.map i.inv
@[simp] | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | mapIso | A functor `F : C ⥤ D` sends isomorphisms `i : X ≅ Y` to isomorphisms `F.obj X ≅ F.obj Y` |
mapIso_symm (F : C ⥤ D) {X Y : C} (i : X ≅ Y) : F.mapIso i.symm = (F.mapIso i).symm :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | mapIso_symm | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.