File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

full_name: CategoryTheory.MorphismProperty
code: /-- A `MorphismProperty C` is a class of morphisms between objects in `C`. -/
def MorphismProperty 
goal: Type (max u v)

full_name: CategoryTheory.instCompleteBooleanAlgebraMorphismProperty
code: instance : CompleteBooleanAlgebra (MorphismProperty C) 
goal: CompleteBooleanAlgebra (CategoryTheory.MorphismProperty C)

full_name: CategoryTheory.MorphismProperty.le_def
code: lemma MorphismProperty.le_def {P Q : MorphismProperty C} :
    P ≤ Q ↔ ∀ {X Y : C} (f : X ⟶ Y), P f → Q f 
goal: P ≤ Q ↔ ∀ {X Y : C} (f : X ⟶ Y), P f → Q f

full_name: CategoryTheory.instInhabitedMorphismProperty
code: instance : Inhabited (MorphismProperty C) 
goal: Inhabited (CategoryTheory.MorphismProperty C)

full_name: CategoryTheory.MorphismProperty.top_eq
code: lemma MorphismProperty.top_eq : (⊤ : MorphismProperty C) = fun _ _ _ => True 
goal: ⊤ = fun x x_1 x => True

full_name: CategoryTheory.MorphismProperty.ext
code: @[ext]
lemma ext (W W' : MorphismProperty C) (h : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f ↔ W' f) :
    W = W' 
goal: W = W'

full_name: CategoryTheory.MorphismProperty.top_apply
code: @[simp]
lemma top_apply {X Y : C} (f : X ⟶ Y) : (⊤ : MorphismProperty C) f 
goal: ⊤ f

full_name: CategoryTheory.MorphismProperty.op
code: /-- The morphism property in `Cᵒᵖ` associated to a morphism property in `C` -/
@[simp]
def op (P : MorphismProperty C) : MorphismProperty Cᵒᵖ 
goal: CategoryTheory.MorphismProperty Cᵒᵖ

full_name: CategoryTheory.MorphismProperty.unop
code: /-- The morphism property in `C` associated to a morphism property in `Cᵒᵖ` -/
@[simp]
def unop (P : MorphismProperty Cᵒᵖ) : MorphismProperty C 
goal: CategoryTheory.MorphismProperty C

full_name: CategoryTheory.MorphismProperty.unop_op
code: theorem unop_op (P : MorphismProperty C) : P.op.unop = P 
goal: P.op.unop = P

full_name: CategoryTheory.MorphismProperty.op_unop
code: theorem op_unop (P : MorphismProperty Cᵒᵖ) : P.unop.op = P 
goal: P.unop.op = P

full_name: CategoryTheory.MorphismProperty.inverseImage
code: /-- The inverse image of a `MorphismProperty D` by a functor `C ⥤ D` -/
def inverseImage (P : MorphismProperty D) (F : C ⥤ D) : MorphismProperty C 
goal: CategoryTheory.MorphismProperty C

full_name: CategoryTheory.MorphismProperty.inverseImage_iff
code: @[simp]
lemma inverseImage_iff (P : MorphismProperty D) (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) :
    P.inverseImage F f ↔ P (F.map f) 
goal: P.inverseImage F f ↔ P (F.map f)

full_name: CategoryTheory.MorphismProperty.map
code: /-- The image (up to isomorphisms) of a `MorphismProperty C` by a functor `C ⥤ D` -/
def map (P : MorphismProperty C) (F : C ⥤ D) : MorphismProperty D 
goal: CategoryTheory.MorphismProperty D

full_name: CategoryTheory.MorphismProperty.map_mem_map
code: lemma map_mem_map (P : MorphismProperty C) (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) (hf : P f) :
    (P.map F) (F.map f) 
goal: P.map F (F.map f)

full_name: CategoryTheory.MorphismProperty.monotone_map
code: lemma monotone_map (F : C ⥤ D) :
    Monotone (map · F) 
goal: Monotone fun x => x.map F

full_name: CategoryTheory.MorphismProperty.RespectsIso.postcomp
code: /-- A morphism property `RespectsIso` if it still holds when composed with an isomorphism -/
class RespectsIso (P : MorphismProperty C) : Prop where
  precomp {X Y Z} (e : X ≅ Y) (f : Y ⟶ Z) (hf : P f) : P (e.hom ≫ f)
  postcomp {X Y Z} (e : Y ≅ Z) (f : X ⟶ Y) (hf : P f) : P (f ≫ e.hom)
goal: P (f ≫ e.hom)

full_name: CategoryTheory.MorphismProperty.RespectsIso.precomp
code: /-- A morphism property `RespectsIso` if it still holds when composed with an isomorphism -/
class RespectsIso (P : MorphismProperty C) : Prop where
  precomp {X Y Z} (e : X ≅ Y) (f : Y ⟶ Z) (hf : P f) : P (e.hom ≫ f)
  postcomp {X Y Z} (e : Y ≅ Z) (f : X ⟶ Y) (hf : P f) : P (f ≫ e.hom)
goal: P (e.hom ≫ f)

full_name: CategoryTheory.MorphismProperty.RespectsIso
code: /-- A morphism property `RespectsIso` if it still holds when composed with an isomorphism -/
class RespectsIso (P : MorphismProperty C) : Prop where
  precomp {X Y Z} (e : X ≅ Y) (f : Y ⟶ Z) (hf : P f) : P (e.hom ≫ f)
  postcomp {X Y Z} (e : Y ≅ Z) (f : X ⟶ Y) (hf : P f) : P (f ≫ e.hom)
goal: Prop

full_name: CategoryTheory.MorphismProperty.RespectsIso.op
code: instance RespectsIso.op (P : MorphismProperty C) [h : RespectsIso P] : RespectsIso P.op 
goal: P.op.RespectsIso

full_name: CategoryTheory.MorphismProperty.RespectsIso.unop
code: instance RespectsIso.unop (P : MorphismProperty Cᵒᵖ) [h : RespectsIso P] : RespectsIso P.unop 
goal: P.unop.RespectsIso

full_name: CategoryTheory.MorphismProperty.RespectsIso.inf
code: /-- The intersection of two isomorphism respecting morphism properties respects isomorphisms. -/
instance RespectsIso.inf (P Q : MorphismProperty C) [RespectsIso P] [RespectsIso Q] :
    RespectsIso (P ⊓ Q) 
goal: (P ⊓ Q).RespectsIso

full_name: CategoryTheory.MorphismProperty.isoClosure
code: /-- The closure by isomorphisms of a `MorphismProperty` -/
def isoClosure (P : MorphismProperty C) : MorphismProperty C 
goal: CategoryTheory.MorphismProperty C

full_name: CategoryTheory.MorphismProperty.le_isoClosure
code: lemma le_isoClosure (P : MorphismProperty C) : P ≤ P.isoClosure 
goal: P ≤ P.isoClosure

full_name: CategoryTheory.MorphismProperty.isoClosure_respectsIso
code: instance isoClosure_respectsIso (P : MorphismProperty C) :
    RespectsIso P.isoClosure 
goal: P.isoClosure.RespectsIso

full_name: CategoryTheory.MorphismProperty.monotone_isoClosure
code: lemma monotone_isoClosure : Monotone (isoClosure (C := C)) 
goal: Monotone CategoryTheory.MorphismProperty.isoClosure

full_name: CategoryTheory.MorphismProperty.cancel_left_of_respectsIso
code: theorem cancel_left_of_respectsIso (P : MorphismProperty C) [hP : RespectsIso P] {X Y Z : C}
    (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] : P (f ≫ g) ↔ P g 
goal: P (f ≫ g) ↔ P g

full_name: CategoryTheory.MorphismProperty.cancel_right_of_respectsIso
code: theorem cancel_right_of_respectsIso (P : MorphismProperty C) [hP : RespectsIso P] {X Y Z : C}
    (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso g] : P (f ≫ g) ↔ P f 
goal: P (f ≫ g) ↔ P f

full_name: CategoryTheory.MorphismProperty.arrow_iso_iff
code: theorem arrow_iso_iff (P : MorphismProperty C) [RespectsIso P] {f g : Arrow C}
    (e : f ≅ g) : P f.hom ↔ P g.hom 
goal: P f.hom ↔ P g.hom

full_name: CategoryTheory.MorphismProperty.arrow_mk_iso_iff
code: theorem arrow_mk_iso_iff (P : MorphismProperty C) [RespectsIso P] {W X Y Z : C}
    {f : W ⟶ X} {g : Y ⟶ Z} (e : Arrow.mk f ≅ Arrow.mk g) : P f ↔ P g 
goal: P f ↔ P g

full_name: CategoryTheory.MorphismProperty.RespectsIso.of_respects_arrow_iso
code: theorem RespectsIso.of_respects_arrow_iso (P : MorphismProperty C)
    (hP : ∀ (f g : Arrow C) (_ : f ≅ g) (_ : P f.hom), P g.hom) : RespectsIso P 
goal: P.RespectsIso

full_name: CategoryTheory.MorphismProperty.isoClosure_eq_iff
code: lemma isoClosure_eq_iff (P : MorphismProperty C) :
    P.isoClosure = P ↔ P.RespectsIso 
goal: P.isoClosure = P ↔ P.RespectsIso

full_name: CategoryTheory.MorphismProperty.isoClosure_eq_self
code: lemma isoClosure_eq_self (P : MorphismProperty C) [P.RespectsIso] :
    P.isoClosure = P 
goal: P.isoClosure = P

full_name: CategoryTheory.MorphismProperty.isoClosure_isoClosure
code: @[simp]
lemma isoClosure_isoClosure (P : MorphismProperty C) :
    P.isoClosure.isoClosure = P.isoClosure 
goal: P.isoClosure.isoClosure = P.isoClosure

full_name: CategoryTheory.MorphismProperty.isoClosure_le_iff
code: lemma isoClosure_le_iff (P Q : MorphismProperty C) [Q.RespectsIso] :
    P.isoClosure ≤ Q ↔ P ≤ Q 
goal: P.isoClosure ≤ Q ↔ P ≤ Q

full_name: CategoryTheory.MorphismProperty.map_respectsIso
code: instance map_respectsIso (P : MorphismProperty C) (F : C ⥤ D) :
    (P.map F).RespectsIso 
goal: (P.map F).RespectsIso

full_name: CategoryTheory.MorphismProperty.map_le_iff
code: lemma map_le_iff (P : MorphismProperty C) {F : C ⥤ D} (Q : MorphismProperty D)
    [RespectsIso Q] :
    P.map F ≤ Q ↔ P ≤ Q.inverseImage F 
goal: P.map F ≤ Q ↔ P ≤ Q.inverseImage F

full_name: CategoryTheory.MorphismProperty.map_isoClosure
code: @[simp]
lemma map_isoClosure (P : MorphismProperty C) (F : C ⥤ D) :
    P.isoClosure.map F = P.map F 
goal: P.isoClosure.map F = P.map F

full_name: CategoryTheory.MorphismProperty.map_id_eq_isoClosure
code: lemma map_id_eq_isoClosure (P : MorphismProperty C) :
    P.map (𝟭 _) = P.isoClosure 
goal: P.map (𝟭 C) = P.isoClosure

full_name: CategoryTheory.MorphismProperty.map_id
code: lemma map_id (P : MorphismProperty C) [RespectsIso P] :
    P.map (𝟭 _) = P 
goal: P.map (𝟭 C) = P

full_name: CategoryTheory.MorphismProperty.map_map
code: @[simp]
lemma map_map (P : MorphismProperty C) (F : C ⥤ D) {E : Type*} [Category E] (G : D ⥤ E) :
    (P.map F).map G = P.map (F ⋙ G) 
goal: (P.map F).map G = P.map (F ⋙ G)

full_name: CategoryTheory.MorphismProperty.RespectsIso.inverseImage
code: instance RespectsIso.inverseImage (P : MorphismProperty D) [RespectsIso P] (F : C ⥤ D) :
    RespectsIso (P.inverseImage F) 
goal: (P.inverseImage F).RespectsIso

full_name: CategoryTheory.MorphismProperty.map_eq_of_iso
code: lemma map_eq_of_iso (P : MorphismProperty C) {F G : C ⥤ D} (e : F ≅ G) :
    P.map F = P.map G 
goal: P.map F = P.map G

full_name: CategoryTheory.MorphismProperty.map_inverseImage_le
code: lemma map_inverseImage_le (P : MorphismProperty D) (F : C ⥤ D) :
    (P.inverseImage F).map F ≤ P.isoClosure 
goal: (P.inverseImage F).map F ≤ P.isoClosure

full_name: CategoryTheory.MorphismProperty.inverseImage_equivalence_inverse_eq_map_functor
code: lemma inverseImage_equivalence_inverse_eq_map_functor
    (P : MorphismProperty D) [RespectsIso P] (E : C ≌ D) :
    P.inverseImage E.functor = P.map E.inverse 
goal: P.inverseImage E.functor = P.map E.inverse

full_name: CategoryTheory.MorphismProperty.inverseImage_equivalence_functor_eq_map_inverse
code: lemma inverseImage_equivalence_functor_eq_map_inverse
    (Q : MorphismProperty C) [RespectsIso Q] (E : C ≌ D) :
    Q.inverseImage E.inverse = Q.map E.functor 
goal: Q.inverseImage E.inverse = Q.map E.functor

full_name: CategoryTheory.MorphismProperty.map_inverseImage_eq_of_isEquivalence
code: lemma map_inverseImage_eq_of_isEquivalence
    (P : MorphismProperty D) [P.RespectsIso] (F : C ⥤ D) [F.IsEquivalence] :
    (P.inverseImage F).map F = P 
goal: (P.inverseImage F).map F = P

full_name: CategoryTheory.MorphismProperty.inverseImage_map_eq_of_isEquivalence
code: lemma inverseImage_map_eq_of_isEquivalence
    (P : MorphismProperty C) [P.RespectsIso] (F : C ⥤ D) [F.IsEquivalence] :
    (P.map F).inverseImage F = P 
goal: (P.map F).inverseImage F = P

full_name: CategoryTheory.MorphismProperty.isomorphisms
code: /-- The `MorphismProperty C` satisfied by isomorphisms in `C`. -/
def isomorphisms : MorphismProperty C 
goal: CategoryTheory.MorphismProperty C

full_name: CategoryTheory.MorphismProperty.monomorphisms
code: /-- The `MorphismProperty C` satisfied by monomorphisms in `C`. -/
def monomorphisms : MorphismProperty C 
goal: CategoryTheory.MorphismProperty C

full_name: CategoryTheory.MorphismProperty.epimorphisms
code: /-- The `MorphismProperty C` satisfied by epimorphisms in `C`. -/
def epimorphisms : MorphismProperty C 
goal: CategoryTheory.MorphismProperty C

full_name: CategoryTheory.MorphismProperty.isomorphisms.iff
code: @[simp]
theorem isomorphisms.iff : (isomorphisms C) f ↔ IsIso f 
goal: CategoryTheory.MorphismProperty.isomorphisms C f ↔ CategoryTheory.IsIso f

full_name: CategoryTheory.MorphismProperty.monomorphisms.iff
code: @[simp]
theorem monomorphisms.iff : (monomorphisms C) f ↔ Mono f 
goal: CategoryTheory.MorphismProperty.monomorphisms C f ↔ CategoryTheory.Mono f

full_name: CategoryTheory.MorphismProperty.epimorphisms.iff
code: @[simp]
theorem epimorphisms.iff : (epimorphisms C) f ↔ Epi f 
goal: CategoryTheory.MorphismProperty.epimorphisms C f ↔ CategoryTheory.Epi f

full_name: CategoryTheory.MorphismProperty.isomorphisms.infer_property
code: theorem isomorphisms.infer_property [hf : IsIso f] : (isomorphisms C) f 
goal: CategoryTheory.MorphismProperty.isomorphisms C f

full_name: CategoryTheory.MorphismProperty.monomorphisms.infer_property
code: theorem monomorphisms.infer_property [hf : Mono f] : (monomorphisms C) f 
goal: CategoryTheory.MorphismProperty.monomorphisms C f

full_name: CategoryTheory.MorphismProperty.epimorphisms.infer_property
code: theorem epimorphisms.infer_property [hf : Epi f] : (epimorphisms C) f 
goal: CategoryTheory.MorphismProperty.epimorphisms C f

full_name: CategoryTheory.MorphismProperty.RespectsIso.monomorphisms
code: instance RespectsIso.monomorphisms : RespectsIso (monomorphisms C) 
goal: (CategoryTheory.MorphismProperty.monomorphisms C).RespectsIso

full_name: CategoryTheory.MorphismProperty.RespectsIso.epimorphisms
code: instance RespectsIso.epimorphisms : RespectsIso (epimorphisms C) 
goal: (CategoryTheory.MorphismProperty.epimorphisms C).RespectsIso

full_name: CategoryTheory.MorphismProperty.RespectsIso.isomorphisms
code: instance RespectsIso.isomorphisms : RespectsIso (isomorphisms C) 
goal: (CategoryTheory.MorphismProperty.isomorphisms C).RespectsIso

full_name: CategoryTheory.MorphismProperty.prod
code: /-- If `W₁` and `W₂` are morphism properties on two categories `C₁` and `C₂`,
this is the induced morphism property on `C₁ × C₂`. -/
def prod {C₁ C₂ : Type*} [Category C₁] [Category C₂]
    (W₁ : MorphismProperty C₁) (W₂ : MorphismProperty C₂) :
    MorphismProperty (C₁ × C₂) 
goal: CategoryTheory.MorphismProperty (C₁ × C₂)

full_name: CategoryTheory.MorphismProperty.pi
code: /-- If `W j` are morphism properties on categories `C j` for all `j`, this is the
induced morphism property on the category `∀ j, C j`. -/
def pi {J : Type w} {C : J → Type u} [∀ j, Category.{v} (C j)]
    (W : ∀ j, MorphismProperty (C j)) : MorphismProperty (∀ j, C j) 
goal: CategoryTheory.MorphismProperty ((j : J) → C j)

full_name: CategoryTheory.MorphismProperty.functorCategory
code: /-- The morphism property on `J ⥤ C` which is defined objectwise
from `W : MorphismProperty C`. -/
def functorCategory (W : MorphismProperty C) (J : Type*) [Category J] :
    MorphismProperty (J ⥤ C) 
goal: CategoryTheory.MorphismProperty (J ⥤ C)

full_name: CategoryTheory.MorphismProperty.arrow
code: /-- Given `W : MorphismProperty C`, this is the morphism property on `Arrow C` of morphisms
whose left and right parts are in `W`. -/
def arrow (W : MorphismProperty C) :
    MorphismProperty (Arrow C) 
goal: CategoryTheory.MorphismProperty (CategoryTheory.Arrow C)

full_name: CategoryTheory.NatTrans.isIso_app_iff_of_iso
code: lemma isIso_app_iff_of_iso {F G : C ⥤ D} (α : F ⟶ G) {X Y : C} (e : X ≅ Y) :
    IsIso (α.app X) ↔ IsIso (α.app Y) 
goal: CategoryTheory.IsIso (α.app X) ↔ CategoryTheory.IsIso (α.app Y)