File: Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean

full_name: CategoryTheory.MorphismProperty.IsInvertedBy
code: /-- If `P : MorphismProperty C` and `F : C ⥤ D`, then
`P.IsInvertedBy F` means that all morphisms in `P` are mapped by `F`
to isomorphisms in `D`. -/
def IsInvertedBy (P : MorphismProperty C) (F : C ⥤ D) : Prop 
goal: Prop

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.of_le
code: lemma of_le (P Q : MorphismProperty C) (F : C ⥤ D) (hQ : Q.IsInvertedBy F) (h : P ≤ Q) :
    P.IsInvertedBy F 
goal: P.IsInvertedBy F

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.of_comp
code: theorem of_comp {C₁ C₂ C₃ : Type*} [Category C₁] [Category C₂] [Category C₃]
    (W : MorphismProperty C₁) (F : C₁ ⥤ C₂) (hF : W.IsInvertedBy F) (G : C₂ ⥤ C₃) :
    W.IsInvertedBy (F ⋙ G) 
goal: W.IsInvertedBy (F.comp G)

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.op
code: theorem op {W : MorphismProperty C} {L : C ⥤ D} (h : W.IsInvertedBy L) : W.op.IsInvertedBy L.op 
goal: W.op.IsInvertedBy L.op

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.rightOp
code: theorem rightOp {W : MorphismProperty C} {L : Cᵒᵖ ⥤ D} (h : W.op.IsInvertedBy L) :
    W.IsInvertedBy L.rightOp 
goal: W.IsInvertedBy L.rightOp

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.leftOp
code: theorem leftOp {W : MorphismProperty C} {L : C ⥤ Dᵒᵖ} (h : W.IsInvertedBy L) :
    W.op.IsInvertedBy L.leftOp 
goal: W.op.IsInvertedBy L.leftOp

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.unop
code: theorem unop {W : MorphismProperty C} {L : Cᵒᵖ ⥤ Dᵒᵖ} (h : W.op.IsInvertedBy L) :
    W.IsInvertedBy L.unop 
goal: W.IsInvertedBy L.unop

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.prod
code: lemma prod {C₁ C₂ : Type*} [Category C₁] [Category C₂]
    {W₁ : MorphismProperty C₁} {W₂ : MorphismProperty C₂}
    {E₁ E₂ : Type*} [Category E₁] [Category E₂] {F₁ : C₁ ⥤ E₁} {F₂ : C₂ ⥤ E₂}
    (h₁ : W₁.IsInvertedBy F₁) (h₂ : W₂.IsInvertedBy F₂) :
    (W₁.prod W₂).IsInvertedBy (F₁.prod F₂) 
goal: (W₁.prod W₂).IsInvertedBy (F₁.prod F₂)

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.pi
code: lemma pi {J : Type w} {C : J → Type u} {D : J → Type u'}
    [∀ j, Category.{v} (C j)] [∀ j, Category.{v'} (D j)]
    (W : ∀ j, MorphismProperty (C j)) (F : ∀ j, C j ⥤ D j)
    (hF : ∀ j, (W j).IsInvertedBy (F j)) :
    (MorphismProperty.pi W).IsInvertedBy (Functor.pi F) 
goal: (CategoryTheory.MorphismProperty.pi W).IsInvertedBy (CategoryTheory.Functor.pi F)

full_name: CategoryTheory.MorphismProperty.FunctorsInverting
code: /-- The full subcategory of `C ⥤ D` consisting of functors inverting morphisms in `W` -/
def FunctorsInverting (W : MorphismProperty C) (D : Type*) [Category D] 
goal: Type (max (max (max u u_1) v) u_2)

full_name: CategoryTheory.MorphismProperty.FunctorsInverting.ext
code: @[ext]
lemma FunctorsInverting.ext {W : MorphismProperty C} {F₁ F₂ : FunctorsInverting W D}
    (h : F₁.obj = F₂.obj) : F₁ = F₂ 
goal: F₁ = F₂

full_name: CategoryTheory.MorphismProperty.instCategoryFunctorsInverting
code: instance (W : MorphismProperty C) (D : Type*) [Category D] : Category (FunctorsInverting W D) 
goal: CategoryTheory.Category.{max u u_2, max (max (max u_2 u_1) u) v} (W.FunctorsInverting D)

full_name: CategoryTheory.MorphismProperty.FunctorsInverting.hom_ext
code: @[ext]
lemma FunctorsInverting.hom_ext {W : MorphismProperty C} {F₁ F₂ : FunctorsInverting W D}
    {α β : F₁ ⟶ F₂} (h : α.app = β.app) : α = β 
goal: α = β

full_name: CategoryTheory.MorphismProperty.FunctorsInverting.mk
code: /-- A constructor for `W.FunctorsInverting D` -/
def FunctorsInverting.mk {W : MorphismProperty C} {D : Type*} [Category D] (F : C ⥤ D)
    (hF : W.IsInvertedBy F) : W.FunctorsInverting D 
goal: W.FunctorsInverting D

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.iff_of_iso
code: theorem IsInvertedBy.iff_of_iso (W : MorphismProperty C) {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) :
    W.IsInvertedBy F₁ ↔ W.IsInvertedBy F₂ 
goal: W.IsInvertedBy F₁ ↔ W.IsInvertedBy F₂

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.isoClosure_iff
code: @[simp]
lemma IsInvertedBy.isoClosure_iff (W : MorphismProperty C) (F : C ⥤ D) :
    W.isoClosure.IsInvertedBy F ↔ W.IsInvertedBy F 
goal: W.isoClosure.IsInvertedBy F ↔ W.IsInvertedBy F

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.iff_comp
code: @[simp]
lemma IsInvertedBy.iff_comp {C₁ C₂ C₃ : Type*} [Category C₁] [Category C₂] [Category C₃]
    (W : MorphismProperty C₁) (F : C₁ ⥤ C₂) (G : C₂ ⥤ C₃) [G.ReflectsIsomorphisms] :
    W.IsInvertedBy (F ⋙ G) ↔ W.IsInvertedBy F 
goal: W.IsInvertedBy (F.comp G) ↔ W.IsInvertedBy F

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.iff_le_inverseImage_isomorphisms
code: lemma IsInvertedBy.iff_le_inverseImage_isomorphisms (W : MorphismProperty C) (F : C ⥤ D) :
    W.IsInvertedBy F ↔ W ≤ (isomorphisms D).inverseImage F 
goal: W.IsInvertedBy F ↔ W ≤ (CategoryTheory.MorphismProperty.isomorphisms D).inverseImage F

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.iff_map_le_isomorphisms
code: lemma IsInvertedBy.iff_map_le_isomorphisms (W : MorphismProperty C) (F : C ⥤ D) :
    W.IsInvertedBy F ↔ W.map F ≤ isomorphisms D 
goal: W.IsInvertedBy F ↔ W.map F ≤ CategoryTheory.MorphismProperty.isomorphisms D

full_name: CategoryTheory.MorphismProperty.IsInvertedBy.map_iff
code: lemma IsInvertedBy.map_iff {C₁ C₂ C₃ : Type*} [Category C₁] [Category C₂] [Category C₃]
    (W : MorphismProperty C₁) (F : C₁ ⥤ C₂) (G : C₂ ⥤ C₃) :
    (W.map F).IsInvertedBy G ↔ W.IsInvertedBy (F ⋙ G) 
goal: (W.map F).IsInvertedBy G ↔ W.IsInvertedBy (F.comp G)