File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

full_name: CategoryTheory.MorphismProperty.LeftFraction.s
code: /-- A left fraction from `X : C` to `Y : C` for `W : MorphismProperty C` consists of the
datum of an object `Y' : C` and maps `f : X ⟶ Y'` and `s : Y ⟶ Y'` such that `W s`. -/
structure LeftFraction (W : MorphismProperty C) (X Y : C) where
  /-- the auxiliary object of a left fraction -/
  {Y' : C}
  /-- the numerator of a left fraction -/
  f : X ⟶ Y'
  /-- the denominator of a left fraction -/
  s : Y ⟶ Y'
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
goal: Y ⟶ self.Y'

full_name: CategoryTheory.MorphismProperty.LeftFraction.f
code: /-- A left fraction from `X : C` to `Y : C` for `W : MorphismProperty C` consists of the
datum of an object `Y' : C` and maps `f : X ⟶ Y'` and `s : Y ⟶ Y'` such that `W s`. -/
structure LeftFraction (W : MorphismProperty C) (X Y : C) where
  /-- the auxiliary object of a left fraction -/
  {Y' : C}
  /-- the numerator of a left fraction -/
  f : X ⟶ Y'
  /-- the denominator of a left fraction -/
  s : Y ⟶ Y'
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
goal: X ⟶ self.Y'

full_name: CategoryTheory.MorphismProperty.LeftFraction.Y'
code: /-- A left fraction from `X : C` to `Y : C` for `W : MorphismProperty C` consists of the
datum of an object `Y' : C` and maps `f : X ⟶ Y'` and `s : Y ⟶ Y'` such that `W s`. -/
structure LeftFraction (W : MorphismProperty C) (X Y : C) where
  /-- the auxiliary object of a left fraction -/
  {Y' : C}
  /-- the numerator of a left fraction -/
  f : X ⟶ Y'
  /-- the denominator of a left fraction -/
  s : Y ⟶ Y'
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
goal: C

full_name: CategoryTheory.MorphismProperty.LeftFraction.hs
code: /-- A left fraction from `X : C` to `Y : C` for `W : MorphismProperty C` consists of the
datum of an object `Y' : C` and maps `f : X ⟶ Y'` and `s : Y ⟶ Y'` such that `W s`. -/
structure LeftFraction (W : MorphismProperty C) (X Y : C) where
  /-- the auxiliary object of a left fraction -/
  {Y' : C}
  /-- the numerator of a left fraction -/
  f : X ⟶ Y'
  /-- the denominator of a left fraction -/
  s : Y ⟶ Y'
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
goal: W self.s

full_name: CategoryTheory.MorphismProperty.LeftFraction
code: /-- A left fraction from `X : C` to `Y : C` for `W : MorphismProperty C` consists of the
datum of an object `Y' : C` and maps `f : X ⟶ Y'` and `s : Y ⟶ Y'` such that `W s`. -/
structure LeftFraction (W : MorphismProperty C) (X Y : C) where
  /-- the auxiliary object of a left fraction -/
  {Y' : C}
  /-- the numerator of a left fraction -/
  f : X ⟶ Y'
  /-- the denominator of a left fraction -/
  s : Y ⟶ Y'
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
goal: Type (max u_1 u_3)

full_name: CategoryTheory.MorphismProperty.LeftFraction.ofHom_Y'
code: /-- The left fraction from `X` to `Y` given by a morphism `f : X ⟶ Y`. -/
@[simps]
def ofHom (f : X ⟶ Y) [W.ContainsIdentities] :
    W.LeftFraction X Y 
goal: (CategoryTheory.MorphismProperty.LeftFraction.ofHom W f).Y' = Y

full_name: CategoryTheory.MorphismProperty.LeftFraction.ofHom
code: /-- The left fraction from `X` to `Y` given by a morphism `f : X ⟶ Y`. -/
@[simps]
def ofHom (f : X ⟶ Y) [W.ContainsIdentities] :
    W.LeftFraction X Y 
goal: W.LeftFraction X Y

full_name: CategoryTheory.MorphismProperty.LeftFraction.ofHom_s
code: /-- The left fraction from `X` to `Y` given by a morphism `f : X ⟶ Y`. -/
@[simps]
def ofHom (f : X ⟶ Y) [W.ContainsIdentities] :
    W.LeftFraction X Y 
goal: (CategoryTheory.MorphismProperty.LeftFraction.ofHom W f).s = CategoryTheory.CategoryStruct.id Y

full_name: CategoryTheory.MorphismProperty.LeftFraction.ofHom_f
code: /-- The left fraction from `X` to `Y` given by a morphism `f : X ⟶ Y`. -/
@[simps]
def ofHom (f : X ⟶ Y) [W.ContainsIdentities] :
    W.LeftFraction X Y 
goal: (CategoryTheory.MorphismProperty.LeftFraction.ofHom W f).f = f

full_name: CategoryTheory.MorphismProperty.LeftFraction.ofInv
code: /-- The left fraction from `X` to `Y` given by a morphism `s : Y ⟶ X` such that `W s`. -/
@[simps]
def ofInv (s : Y ⟶ X) (hs : W s) :
    W.LeftFraction X Y 
goal: W.LeftFraction X Y

full_name: CategoryTheory.MorphismProperty.LeftFraction.ofInv_Y'
code: /-- The left fraction from `X` to `Y` given by a morphism `s : Y ⟶ X` such that `W s`. -/
@[simps]
def ofInv (s : Y ⟶ X) (hs : W s) :
    W.LeftFraction X Y 
goal: (CategoryTheory.MorphismProperty.LeftFraction.ofInv s hs).Y' = X

full_name: CategoryTheory.MorphismProperty.LeftFraction.ofInv_s
code: /-- The left fraction from `X` to `Y` given by a morphism `s : Y ⟶ X` such that `W s`. -/
@[simps]
def ofInv (s : Y ⟶ X) (hs : W s) :
    W.LeftFraction X Y 
goal: (CategoryTheory.MorphismProperty.LeftFraction.ofInv s hs).s = s

full_name: CategoryTheory.MorphismProperty.LeftFraction.ofInv_f
code: /-- The left fraction from `X` to `Y` given by a morphism `s : Y ⟶ X` such that `W s`. -/
@[simps]
def ofInv (s : Y ⟶ X) (hs : W s) :
    W.LeftFraction X Y 
goal: (CategoryTheory.MorphismProperty.LeftFraction.ofInv s hs).f = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.MorphismProperty.LeftFraction.map
code: /-- If `φ : W.LeftFraction X Y` and `L` is a functor which inverts `W`, this is the
induced morphism `L.obj X ⟶ L.obj Y`  -/
noncomputable def map (φ : W.LeftFraction X Y) (L : C ⥤ D) (hL : W.IsInvertedBy L) :
    L.obj X ⟶ L.obj Y 
goal: L.obj X ⟶ L.obj Y

full_name: CategoryTheory.MorphismProperty.LeftFraction.map_comp_map_s
code: @[reassoc (attr := simp)]
lemma map_comp_map_s (φ : W.LeftFraction X Y) (L : C ⥤ D) (hL : W.IsInvertedBy L) :
    φ.map L hL ≫ L.map φ.s = L.map φ.f 
goal: CategoryTheory.CategoryStruct.comp (φ.map L hL) (L.map φ.s) = L.map φ.f

full_name: CategoryTheory.MorphismProperty.LeftFraction.map_ofHom
code: lemma map_ofHom (f : X ⟶ Y) (L : C ⥤ D) (hL : W.IsInvertedBy L) [W.ContainsIdentities] :
    (ofHom W f).map L hL = L.map f 
goal: (CategoryTheory.MorphismProperty.LeftFraction.ofHom W f).map L hL = L.map f

full_name: CategoryTheory.MorphismProperty.LeftFraction.map_ofInv_hom_id
code: @[reassoc (attr := simp)]
lemma map_ofInv_hom_id (s : Y ⟶ X) (hs : W s) (L : C ⥤ D) (hL : W.IsInvertedBy L) :
    (ofInv s hs).map L hL ≫ L.map s = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.MorphismProperty.LeftFraction.ofInv s hs).map L hL) (L.map s) =
  CategoryTheory.CategoryStruct.id (L.obj X)

full_name: CategoryTheory.MorphismProperty.LeftFraction.map_hom_ofInv_id
code: @[reassoc (attr := simp)]
lemma map_hom_ofInv_id (s : Y ⟶ X) (hs : W s) (L : C ⥤ D) (hL : W.IsInvertedBy L) :
    L.map s ≫ (ofInv s hs).map L hL = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (L.map s) ((CategoryTheory.MorphismProperty.LeftFraction.ofInv s hs).map L hL) =
  CategoryTheory.CategoryStruct.id (L.obj Y)

full_name: CategoryTheory.MorphismProperty.LeftFraction.cases
code: lemma cases (α : W.LeftFraction X Y) :
    ∃ (Y' : C) (f : X ⟶ Y') (s : Y ⟶ Y') (hs : W s), α = LeftFraction.mk f s hs 
goal: ∃ Y' f s, ∃ (hs : W s), α = CategoryTheory.MorphismProperty.LeftFraction.mk f s hs

full_name: CategoryTheory.MorphismProperty.RightFraction.s
code: /-- A right fraction from `X : C` to `Y : C` for `W : MorphismProperty C` consists of the
datum of an object `X' : C` and maps `s : X' ⟶ X` and `f : X' ⟶ Y` such that `W s`. -/
structure RightFraction (W : MorphismProperty C) (X Y : C) where
  /-- the auxiliary object of a right fraction -/
  {X' : C}
  /-- the denominator of a right fraction -/
  s : X' ⟶ X
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
  /-- the numerator of a right fraction -/
  f : X' ⟶ Y
goal: self.X' ⟶ X

full_name: CategoryTheory.MorphismProperty.RightFraction
code: /-- A right fraction from `X : C` to `Y : C` for `W : MorphismProperty C` consists of the
datum of an object `X' : C` and maps `s : X' ⟶ X` and `f : X' ⟶ Y` such that `W s`. -/
structure RightFraction (W : MorphismProperty C) (X Y : C) where
  /-- the auxiliary object of a right fraction -/
  {X' : C}
  /-- the denominator of a right fraction -/
  s : X' ⟶ X
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
  /-- the numerator of a right fraction -/
  f : X' ⟶ Y
goal: Type (max u_1 u_3)

full_name: CategoryTheory.MorphismProperty.RightFraction.hs
code: /-- A right fraction from `X : C` to `Y : C` for `W : MorphismProperty C` consists of the
datum of an object `X' : C` and maps `s : X' ⟶ X` and `f : X' ⟶ Y` such that `W s`. -/
structure RightFraction (W : MorphismProperty C) (X Y : C) where
  /-- the auxiliary object of a right fraction -/
  {X' : C}
  /-- the denominator of a right fraction -/
  s : X' ⟶ X
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
  /-- the numerator of a right fraction -/
  f : X' ⟶ Y
goal: W self.s

full_name: CategoryTheory.MorphismProperty.RightFraction.f
code: /-- A right fraction from `X : C` to `Y : C` for `W : MorphismProperty C` consists of the
datum of an object `X' : C` and maps `s : X' ⟶ X` and `f : X' ⟶ Y` such that `W s`. -/
structure RightFraction (W : MorphismProperty C) (X Y : C) where
  /-- the auxiliary object of a right fraction -/
  {X' : C}
  /-- the denominator of a right fraction -/
  s : X' ⟶ X
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
  /-- the numerator of a right fraction -/
  f : X' ⟶ Y
goal: self.X' ⟶ Y

full_name: CategoryTheory.MorphismProperty.RightFraction.X'
code: /-- A right fraction from `X : C` to `Y : C` for `W : MorphismProperty C` consists of the
datum of an object `X' : C` and maps `s : X' ⟶ X` and `f : X' ⟶ Y` such that `W s`. -/
structure RightFraction (W : MorphismProperty C) (X Y : C) where
  /-- the auxiliary object of a right fraction -/
  {X' : C}
  /-- the denominator of a right fraction -/
  s : X' ⟶ X
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
  /-- the numerator of a right fraction -/
  f : X' ⟶ Y
goal: C

full_name: CategoryTheory.MorphismProperty.RightFraction.ofHom_X'
code: /-- The right fraction from `X` to `Y` given by a morphism `f : X ⟶ Y`. -/
@[simps]
def ofHom (f : X ⟶ Y) [W.ContainsIdentities] :
    W.RightFraction X Y 
goal: (CategoryTheory.MorphismProperty.RightFraction.ofHom W f).X' = X

full_name: CategoryTheory.MorphismProperty.RightFraction.ofHom_f
code: /-- The right fraction from `X` to `Y` given by a morphism `f : X ⟶ Y`. -/
@[simps]
def ofHom (f : X ⟶ Y) [W.ContainsIdentities] :
    W.RightFraction X Y 
goal: (CategoryTheory.MorphismProperty.RightFraction.ofHom W f).f = f

full_name: CategoryTheory.MorphismProperty.RightFraction.ofHom_s
code: /-- The right fraction from `X` to `Y` given by a morphism `f : X ⟶ Y`. -/
@[simps]
def ofHom (f : X ⟶ Y) [W.ContainsIdentities] :
    W.RightFraction X Y 
goal: (CategoryTheory.MorphismProperty.RightFraction.ofHom W f).s = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.MorphismProperty.RightFraction.ofHom
code: /-- The right fraction from `X` to `Y` given by a morphism `f : X ⟶ Y`. -/
@[simps]
def ofHom (f : X ⟶ Y) [W.ContainsIdentities] :
    W.RightFraction X Y 
goal: W.RightFraction X Y

full_name: CategoryTheory.MorphismProperty.RightFraction.ofInv_s
code: /-- The right fraction from `X` to `Y` given by a morphism `s : Y ⟶ X` such that `W s`. -/
@[simps]
def ofInv (s : Y ⟶ X) (hs : W s) :
    W.RightFraction X Y 
goal: (CategoryTheory.MorphismProperty.RightFraction.ofInv s hs).s = s

full_name: CategoryTheory.MorphismProperty.RightFraction.ofInv_X'
code: /-- The right fraction from `X` to `Y` given by a morphism `s : Y ⟶ X` such that `W s`. -/
@[simps]
def ofInv (s : Y ⟶ X) (hs : W s) :
    W.RightFraction X Y 
goal: (CategoryTheory.MorphismProperty.RightFraction.ofInv s hs).X' = Y

full_name: CategoryTheory.MorphismProperty.RightFraction.ofInv
code: /-- The right fraction from `X` to `Y` given by a morphism `s : Y ⟶ X` such that `W s`. -/
@[simps]
def ofInv (s : Y ⟶ X) (hs : W s) :
    W.RightFraction X Y 
goal: W.RightFraction X Y

full_name: CategoryTheory.MorphismProperty.RightFraction.ofInv_f
code: /-- The right fraction from `X` to `Y` given by a morphism `s : Y ⟶ X` such that `W s`. -/
@[simps]
def ofInv (s : Y ⟶ X) (hs : W s) :
    W.RightFraction X Y 
goal: (CategoryTheory.MorphismProperty.RightFraction.ofInv s hs).f = CategoryTheory.CategoryStruct.id Y

full_name: CategoryTheory.MorphismProperty.RightFraction.map
code: /-- If `φ : W.RightFraction X Y` and `L` is a functor which inverts `W`, this is the
induced morphism `L.obj X ⟶ L.obj Y`  -/
noncomputable def map (φ : W.RightFraction X Y) (L : C ⥤ D) (hL : W.IsInvertedBy L) :
    L.obj X ⟶ L.obj Y 
goal: L.obj X ⟶ L.obj Y

full_name: CategoryTheory.MorphismProperty.RightFraction.map_s_comp_map
code: @[reassoc (attr := simp)]
lemma map_s_comp_map (φ : W.RightFraction X Y) (L : C ⥤ D) (hL : W.IsInvertedBy L) :
    L.map φ.s ≫ φ.map L hL = L.map φ.f 
goal: CategoryTheory.CategoryStruct.comp (L.map φ.s) (φ.map L hL) = L.map φ.f

full_name: CategoryTheory.MorphismProperty.RightFraction.map_ofHom
code: @[simp]
lemma map_ofHom (f : X ⟶ Y) (L : C ⥤ D) (hL : W.IsInvertedBy L) [W.ContainsIdentities] :
    (ofHom W f).map L hL = L.map f 
goal: (CategoryTheory.MorphismProperty.RightFraction.ofHom W f).map L hL = L.map f

full_name: CategoryTheory.MorphismProperty.RightFraction.map_ofInv_hom_id
code: @[reassoc (attr := simp)]
lemma map_ofInv_hom_id (s : Y ⟶ X) (hs : W s) (L : C ⥤ D) (hL : W.IsInvertedBy L) :
    (ofInv s hs).map L hL ≫ L.map s = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.MorphismProperty.RightFraction.ofInv s hs).map L hL) (L.map s) =
  CategoryTheory.CategoryStruct.id (L.obj X)

full_name: CategoryTheory.MorphismProperty.RightFraction.map_hom_ofInv_id
code: @[reassoc (attr := simp)]
lemma map_hom_ofInv_id (s : Y ⟶ X) (hs : W s) (L : C ⥤ D) (hL : W.IsInvertedBy L) :
    L.map s ≫ (ofInv s hs).map L hL = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (L.map s) ((CategoryTheory.MorphismProperty.RightFraction.ofInv s hs).map L hL) =
  CategoryTheory.CategoryStruct.id (L.obj Y)

full_name: CategoryTheory.MorphismProperty.RightFraction.cases
code: lemma cases (α : W.RightFraction X Y) :
    ∃ (X' : C) (s : X' ⟶ X) (hs : W s) (f : X' ⟶ Y) , α = RightFraction.mk s hs f 
goal: ∃ X' s, ∃ (hs : W s), ∃ f, α = CategoryTheory.MorphismProperty.RightFraction.mk s hs f

full_name: CategoryTheory.MorphismProperty.HasLeftCalculusOfFractions.ext
code: /-- A multiplicative morphism property `W` has left calculus of fractions if
any right fraction can be turned into a left fraction and that two morphisms
that can be equalized by precomposition with a morphism in `W` can also
be equalized by postcomposition with a morphism in `W`. -/
class HasLeftCalculusOfFractions extends W.IsMultiplicative : Prop where
  exists_leftFraction ⦃X Y : C⦄ (φ : W.RightFraction X Y) :
    ∃ (ψ : W.LeftFraction X Y), φ.f ≫ ψ.s = φ.s ≫ ψ.f
  ext : ∀ ⦃X' X Y : C⦄ (f₁ f₂ : X ⟶ Y) (s : X' ⟶ X) (_ : W s)
    (_ : s ≫ f₁ = s ≫ f₂), ∃ (Y' : C) (t : Y ⟶ Y') (_ : W t), f₁ ≫ t = f₂ ≫ t
goal: W s →
  CategoryTheory.CategoryStruct.comp s f₁ = CategoryTheory.CategoryStruct.comp s f₂ →
    ∃ Y' t, ∃ (_ : W t), CategoryTheory.CategoryStruct.comp f₁ t = CategoryTheory.CategoryStruct.comp f₂ t

full_name: CategoryTheory.MorphismProperty.HasLeftCalculusOfFractions.exists_leftFraction
code: /-- A multiplicative morphism property `W` has left calculus of fractions if
any right fraction can be turned into a left fraction and that two morphisms
that can be equalized by precomposition with a morphism in `W` can also
be equalized by postcomposition with a morphism in `W`. -/
class HasLeftCalculusOfFractions extends W.IsMultiplicative : Prop where
  exists_leftFraction ⦃X Y : C⦄ (φ : W.RightFraction X Y) :
    ∃ (ψ : W.LeftFraction X Y), φ.f ≫ ψ.s = φ.s ≫ ψ.f
  ext : ∀ ⦃X' X Y : C⦄ (f₁ f₂ : X ⟶ Y) (s : X' ⟶ X) (_ : W s)
    (_ : s ≫ f₁ = s ≫ f₂), ∃ (Y' : C) (t : Y ⟶ Y') (_ : W t), f₁ ≫ t = f₂ ≫ t
goal: ∃ ψ, CategoryTheory.CategoryStruct.comp φ.f ψ.s = CategoryTheory.CategoryStruct.comp φ.s ψ.f

full_name: CategoryTheory.MorphismProperty.HasLeftCalculusOfFractions
code: /-- A multiplicative morphism property `W` has left calculus of fractions if
any right fraction can be turned into a left fraction and that two morphisms
that can be equalized by precomposition with a morphism in `W` can also
be equalized by postcomposition with a morphism in `W`. -/
class HasLeftCalculusOfFractions extends W.IsMultiplicative : Prop where
  exists_leftFraction ⦃X Y : C⦄ (φ : W.RightFraction X Y) :
    ∃ (ψ : W.LeftFraction X Y), φ.f ≫ ψ.s = φ.s ≫ ψ.f
  ext : ∀ ⦃X' X Y : C⦄ (f₁ f₂ : X ⟶ Y) (s : X' ⟶ X) (_ : W s)
    (_ : s ≫ f₁ = s ≫ f₂), ∃ (Y' : C) (t : Y ⟶ Y') (_ : W t), f₁ ≫ t = f₂ ≫ t
goal: Prop

full_name: CategoryTheory.MorphismProperty.HasRightCalculusOfFractions
code: /-- A multiplicative morphism property `W` has right calculus of fractions if
any left fraction can be turned into a right fraction and that two morphisms
that can be equalized by postcomposition with a morphism in `W` can also
be equalized by precomposition with a morphism in `W`. -/
class HasRightCalculusOfFractions extends W.IsMultiplicative : Prop where
  exists_rightFraction ⦃X Y : C⦄ (φ : W.LeftFraction X Y) :
    ∃ (ψ : W.RightFraction X Y), ψ.s ≫ φ.f = ψ.f ≫ φ.s
  ext : ∀ ⦃X Y Y' : C⦄ (f₁ f₂ : X ⟶ Y) (s : Y ⟶ Y') (_ : W s)
    (_ : f₁ ≫ s = f₂ ≫ s), ∃ (X' : C) (t : X' ⟶ X) (_ : W t), t ≫ f₁ = t ≫ f₂
goal: Prop

full_name: CategoryTheory.MorphismProperty.HasRightCalculusOfFractions.ext
code: /-- A multiplicative morphism property `W` has right calculus of fractions if
any left fraction can be turned into a right fraction and that two morphisms
that can be equalized by postcomposition with a morphism in `W` can also
be equalized by precomposition with a morphism in `W`. -/
class HasRightCalculusOfFractions extends W.IsMultiplicative : Prop where
  exists_rightFraction ⦃X Y : C⦄ (φ : W.LeftFraction X Y) :
    ∃ (ψ : W.RightFraction X Y), ψ.s ≫ φ.f = ψ.f ≫ φ.s
  ext : ∀ ⦃X Y Y' : C⦄ (f₁ f₂ : X ⟶ Y) (s : Y ⟶ Y') (_ : W s)
    (_ : f₁ ≫ s = f₂ ≫ s), ∃ (X' : C) (t : X' ⟶ X) (_ : W t), t ≫ f₁ = t ≫ f₂
goal: W s →
  CategoryTheory.CategoryStruct.comp f₁ s = CategoryTheory.CategoryStruct.comp f₂ s →
    ∃ X' t, ∃ (_ : W t), CategoryTheory.CategoryStruct.comp t f₁ = CategoryTheory.CategoryStruct.comp t f₂

full_name: CategoryTheory.MorphismProperty.HasRightCalculusOfFractions.exists_rightFraction
code: /-- A multiplicative morphism property `W` has right calculus of fractions if
any left fraction can be turned into a right fraction and that two morphisms
that can be equalized by postcomposition with a morphism in `W` can also
be equalized by precomposition with a morphism in `W`. -/
class HasRightCalculusOfFractions extends W.IsMultiplicative : Prop where
  exists_rightFraction ⦃X Y : C⦄ (φ : W.LeftFraction X Y) :
    ∃ (ψ : W.RightFraction X Y), ψ.s ≫ φ.f = ψ.f ≫ φ.s
  ext : ∀ ⦃X Y Y' : C⦄ (f₁ f₂ : X ⟶ Y) (s : Y ⟶ Y') (_ : W s)
    (_ : f₁ ≫ s = f₂ ≫ s), ∃ (X' : C) (t : X' ⟶ X) (_ : W t), t ≫ f₁ = t ≫ f₂
goal: ∃ ψ, CategoryTheory.CategoryStruct.comp ψ.s φ.f = CategoryTheory.CategoryStruct.comp ψ.f φ.s

full_name: CategoryTheory.MorphismProperty.RightFraction.exists_leftFraction
code: lemma RightFraction.exists_leftFraction [W.HasLeftCalculusOfFractions] {X Y : C}
    (φ : W.RightFraction X Y) : ∃ (ψ : W.LeftFraction X Y), φ.f ≫ ψ.s = φ.s ≫ ψ.f 
goal: ∃ ψ, CategoryTheory.CategoryStruct.comp φ.f ψ.s = CategoryTheory.CategoryStruct.comp φ.s ψ.f

full_name: CategoryTheory.MorphismProperty.RightFraction.leftFraction
code: /-- A choice of a left fraction deduced from a right fraction for a morphism property `W`
when `W` has left calculus of fractions. -/
noncomputable def RightFraction.leftFraction [W.HasLeftCalculusOfFractions] {X Y : C}
    (φ : W.RightFraction X Y) : W.LeftFraction X Y 
goal: W.LeftFraction X Y

full_name: CategoryTheory.MorphismProperty.RightFraction.leftFraction_fac
code: @[reassoc]
lemma RightFraction.leftFraction_fac [W.HasLeftCalculusOfFractions] {X Y : C}
    (φ : W.RightFraction X Y) : φ.f ≫ φ.leftFraction.s = φ.s ≫ φ.leftFraction.f 
goal: CategoryTheory.CategoryStruct.comp φ.f φ.leftFraction.s = CategoryTheory.CategoryStruct.comp φ.s φ.leftFraction.f

full_name: CategoryTheory.MorphismProperty.LeftFraction.exists_rightFraction
code: lemma LeftFraction.exists_rightFraction [W.HasRightCalculusOfFractions] {X Y : C}
    (φ : W.LeftFraction X Y) : ∃ (ψ : W.RightFraction X Y), ψ.s ≫ φ.f = ψ.f ≫ φ.s 
goal: ∃ ψ, CategoryTheory.CategoryStruct.comp ψ.s φ.f = CategoryTheory.CategoryStruct.comp ψ.f φ.s

full_name: CategoryTheory.MorphismProperty.LeftFraction.rightFraction
code: /-- A choice of a right fraction deduced from a left fraction for a morphism property `W`
when `W` has right calculus of fractions. -/
noncomputable def LeftFraction.rightFraction [W.HasRightCalculusOfFractions] {X Y : C}
    (φ : W.LeftFraction X Y) : W.RightFraction X Y 
goal: W.RightFraction X Y

full_name: CategoryTheory.MorphismProperty.LeftFraction.rightFraction_fac
code: @[reassoc]
lemma LeftFraction.rightFraction_fac [W.HasRightCalculusOfFractions] {X Y : C}
    (φ : W.LeftFraction X Y) : φ.rightFraction.s ≫ φ.f = φ.rightFraction.f ≫ φ.s 
goal: CategoryTheory.CategoryStruct.comp φ.rightFraction.s φ.f = CategoryTheory.CategoryStruct.comp φ.rightFraction.f φ.s

full_name: CategoryTheory.MorphismProperty.LeftFractionRel
code: /-- The equivalence relation on left fractions for a morphism property `W`. -/
def LeftFractionRel {X Y : C} (z₁ z₂ : W.LeftFraction X Y) : Prop 
goal: Prop

full_name: CategoryTheory.MorphismProperty.LeftFractionRel.refl
code: lemma refl {X Y : C} (z : W.LeftFraction X Y) : LeftFractionRel z z 
goal: CategoryTheory.MorphismProperty.LeftFractionRel z z

full_name: CategoryTheory.MorphismProperty.LeftFractionRel.symm
code: lemma symm {X Y : C} {z₁ z₂ : W.LeftFraction X Y} (h : LeftFractionRel z₁ z₂) :
    LeftFractionRel z₂ z₁ 
goal: CategoryTheory.MorphismProperty.LeftFractionRel z₂ z₁

full_name: CategoryTheory.MorphismProperty.LeftFractionRel.trans
code: lemma trans {X Y : C} {z₁ z₂ z₃ : W.LeftFraction X Y}
    [HasLeftCalculusOfFractions W]
    (h₁₂ : LeftFractionRel z₁ z₂) (h₂₃ : LeftFractionRel z₂ z₃) :
    LeftFractionRel z₁ z₃ 
goal: CategoryTheory.MorphismProperty.LeftFractionRel z₁ z₃

full_name: CategoryTheory.MorphismProperty.equivalenceLeftFractionRel
code: lemma equivalenceLeftFractionRel (X Y : C) :
    @_root_.Equivalence (W.LeftFraction X Y) LeftFractionRel 
goal: Equivalence CategoryTheory.MorphismProperty.LeftFractionRel

full_name: CategoryTheory.MorphismProperty.LeftFraction.comp₀
code: /-- Auxiliary definition for the composition of left fractions. -/
@[simp]
def comp₀ {X Y Z : C} (z₁ : W.LeftFraction X Y) (z₂ : W.LeftFraction Y Z)
    (z₃ : W.LeftFraction z₁.Y' z₂.Y') :
    W.LeftFraction X Z 
goal: W.LeftFraction X Z

full_name: CategoryTheory.MorphismProperty.LeftFraction.comp₀_rel
code: /-- The equivalence class of `z₁.comp₀ z₂ z₃` does not depend on the choice of `z₃` provided
they satisfy the compatibility `z₂.f ≫ z₃.s = z₁.s ≫ z₃.f`. -/
lemma comp₀_rel {X Y Z : C} (z₁ : W.LeftFraction X Y) (z₂ : W.LeftFraction Y Z)
    (z₃ z₃' : W.LeftFraction z₁.Y' z₂.Y') (h₃ : z₂.f ≫ z₃.s = z₁.s ≫ z₃.f)
    (h₃' : z₂.f ≫ z₃'.s = z₁.s ≫ z₃'.f) :
    LeftFractionRel (z₁.comp₀ z₂ z₃) (z₁.comp₀ z₂ z₃') 
goal: CategoryTheory.MorphismProperty.LeftFractionRel (z₁.comp₀ z₂ z₃) (z₁.comp₀ z₂ z₃')

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom
code: /-- The morphisms in the constructed localized category for a morphism property `W`
that has left calculus of fractions are equivalence classes of left fractions. -/
def Localization.Hom (X Y : C) 
goal: Type (max u_1 u_3)

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom.mk
code: /-- The morphism in the constructed localized category that is induced by a left fraction. -/
def Localization.Hom.mk {X Y : C} (z : W.LeftFraction X Y) : Localization.Hom W X Y 
goal: CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom W X Y

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom.mk_surjective
code: lemma Localization.Hom.mk_surjective {X Y : C} (f : Localization.Hom W X Y) :
    ∃ (z : W.LeftFraction X Y), f = mk z 
goal: ∃ z, f = CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom.mk z

full_name: CategoryTheory.MorphismProperty.LeftFraction.comp
code: /-- Auxiliary definition towards the definition of the composition of morphisms
in the constructed localized category for a morphism property that has
left calculus of fractions. -/
noncomputable def comp {X Y Z : C} (z₁ : W.LeftFraction X Y) (z₂ : W.LeftFraction Y Z) :
    Localization.Hom W X Z 
goal: CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom W X Z

full_name: CategoryTheory.MorphismProperty.LeftFraction.comp_eq
code: lemma comp_eq {X Y Z : C} (z₁ : W.LeftFraction X Y) (z₂ : W.LeftFraction Y Z)
    (z₃ : W.LeftFraction z₁.Y' z₂.Y') (h₃ : z₂.f ≫ z₃.s = z₁.s ≫ z₃.f) :
    z₁.comp z₂ = Localization.Hom.mk (z₁.comp₀ z₂ z₃) 
goal: z₁.comp z₂ = CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom.mk (z₁.comp₀ z₂ z₃)

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom.comp
code: /-- Composition of morphisms in the constructed localized category
for a morphism property that has left calculus of fractions. -/
noncomputable def Hom.comp {X Y Z : C} (z₁ : Hom W X Y) (z₂ : Hom W Y Z) : Hom W X Z 
goal: CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom W X Z

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom.comp_eq
code: lemma Hom.comp_eq {X Y Z : C} (z₁ : W.LeftFraction X Y) (z₂ : W.LeftFraction Y Z) :
    Hom.comp (mk z₁) (mk z₂) = z₁.comp z₂ 
goal: (CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom.mk z₁).comp
    (CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom.mk z₂) =
  z₁.comp z₂

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization
code: /-- The constructed localized category for a morphism property
that has left calculus of fractions. -/
@[nolint unusedArguments]
def Localization (_ : MorphismProperty C) 
goal: CategoryTheory.MorphismProperty C → Type u_1

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.instCategory
code: noncomputable instance : Category (Localization W) 
goal: CategoryTheory.Category.{max u_3 u_1, u_1} (CategoryTheory.MorphismProperty.LeftFraction.Localization W)

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Q
code: /-- The localization functor to the constructed localized category for a morphism property
that has left calculus of fractions. -/
@[simps obj]
def Q : C ⥤ Localization W 
goal: CategoryTheory.Functor C (CategoryTheory.MorphismProperty.LeftFraction.Localization W)

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Q_obj
code: /-- The localization functor to the constructed localized category for a morphism property
that has left calculus of fractions. -/
@[simps obj]
def Q : C ⥤ Localization W 
goal: (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj X = X

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk
code: /-- The morphism on `Localization W` that is induced by a left fraction. -/
abbrev homMk {X Y : C} (f : W.LeftFraction X Y) : (Q W).obj X ⟶ (Q W).obj Y 
goal: (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj X ⟶
  (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj Y

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk_eq_hom_mk
code: lemma homMk_eq_hom_mk {X Y : C} (f : W.LeftFraction X Y) : homMk f = Hom.mk f 
goal: CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk f =
  CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom.mk f

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Q_map
code: lemma Q_map {X Y : C} (f : X ⟶ Y) : (Q W).map f = homMk (ofHom W f) 
goal: (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).map f =
  CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk
    (CategoryTheory.MorphismProperty.LeftFraction.ofHom W f)

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk_comp_homMk
code: lemma homMk_comp_homMk {X Y Z : C} (z₁ : W.LeftFraction X Y) (z₂ : W.LeftFraction Y Z)
    (z₃ : W.LeftFraction z₁.Y' z₂.Y') (h₃ : z₂.f ≫ z₃.s = z₁.s ≫ z₃.f) :
    homMk z₁ ≫ homMk z₂ = homMk (z₁.comp₀ z₂ z₃) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk z₁)
    (CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk z₂) =
  CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk (z₁.comp₀ z₂ z₃)

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk_eq_of_leftFractionRel
code: lemma homMk_eq_of_leftFractionRel {X Y : C} (z₁ z₂ : W.LeftFraction X Y)
    (h : LeftFractionRel z₁ z₂) :
    homMk z₁ = homMk z₂ 
goal: CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk z₁ =
  CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk z₂

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk_eq_iff_leftFractionRel
code: lemma homMk_eq_iff_leftFractionRel {X Y : C} (z₁ z₂ : W.LeftFraction X Y) :
    homMk z₁ = homMk z₂ ↔ LeftFractionRel z₁ z₂ 
goal: CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk z₁ =
    CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk z₂ ↔
  CategoryTheory.MorphismProperty.LeftFractionRel z₁ z₂

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Qinv
code: /-- The morphism in `Localization W` that is the formal inverse of a morphism
which belongs to `W`. -/
def Qinv {X Y : C} (s : X ⟶ Y) (hs : W s) : (Q W).obj Y ⟶ (Q W).obj X 
goal: (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj Y ⟶
  (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj X

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Q_map_comp_Qinv
code: lemma Q_map_comp_Qinv {X Y Y' : C} (f : X ⟶ Y') (s : Y ⟶ Y') (hs : W s) :
    (Q W).map f ≫ Qinv s hs = homMk (mk f s hs) 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).map f)
    (CategoryTheory.MorphismProperty.LeftFraction.Localization.Qinv s hs) =
  CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk
    (CategoryTheory.MorphismProperty.LeftFraction.mk f s hs)

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Qiso_hom
code: /-- The isomorphism in `Localization W` that is induced by a morphism in `W`. -/
@[simps]
def Qiso {X Y : C} (s : X ⟶ Y) (hs : W s) : (Q W).obj X ≅ (Q W).obj Y 
goal: (CategoryTheory.MorphismProperty.LeftFraction.Localization.Qiso s hs).hom =
  (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).map s

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Qiso_inv
code: /-- The isomorphism in `Localization W` that is induced by a morphism in `W`. -/
@[simps]
def Qiso {X Y : C} (s : X ⟶ Y) (hs : W s) : (Q W).obj X ≅ (Q W).obj Y 
goal: (CategoryTheory.MorphismProperty.LeftFraction.Localization.Qiso s hs).inv =
  CategoryTheory.MorphismProperty.LeftFraction.Localization.Qinv s hs

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Qiso
code: /-- The isomorphism in `Localization W` that is induced by a morphism in `W`. -/
@[simps]
def Qiso {X Y : C} (s : X ⟶ Y) (hs : W s) : (Q W).obj X ≅ (Q W).obj Y 
goal: (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj X ≅
  (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj Y

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Qiso_hom_inv_id
code: @[reassoc (attr := simp)]
lemma Qiso_hom_inv_id {X Y : C} (s : X ⟶ Y) (hs : W s) :
    (Q W).map s ≫ Qinv s hs = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).map s)
    (CategoryTheory.MorphismProperty.LeftFraction.Localization.Qinv s hs) =
  CategoryTheory.CategoryStruct.id ((CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj X)

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Qiso_inv_hom_id
code: @[reassoc (attr := simp)]
lemma Qiso_inv_hom_id {X Y : C} (s : X ⟶ Y) (hs : W s) :
    Qinv s hs  ≫ (Q W).map s = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MorphismProperty.LeftFraction.Localization.Qinv s hs)
    ((CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).map s) =
  CategoryTheory.CategoryStruct.id ((CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj Y)

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.instIsIsoQinv
code: instance {X Y : C} (s : X ⟶ Y) (hs : W s) : IsIso (Qinv s hs) 
goal: CategoryTheory.IsIso (CategoryTheory.MorphismProperty.LeftFraction.Localization.Qinv s hs)

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom.map
code: /-- The image by a functor which inverts `W` of an equivalence class of left fractions. -/
noncomputable def Hom.map {X Y : C} (f : Hom W X Y) (F : C ⥤ E) (hF : W.IsInvertedBy F) :
    F.obj X ⟶ F.obj Y 
goal: F.obj X ⟶ F.obj Y

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom.map_mk
code: @[simp]
lemma Hom.map_mk {X Y : C} (f : LeftFraction W X Y)
    (F : C ⥤ E) (hF : W.IsInvertedBy F) :
  Hom.map (Hom.mk f) F hF = f.map F hF 
goal: (CategoryTheory.MorphismProperty.LeftFraction.Localization.Hom.mk f).map F hF = f.map F hF

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.StrictUniversalPropertyFixedTarget.inverts
code: lemma inverts : W.IsInvertedBy (Q W) 
goal: W.IsInvertedBy (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W)

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.StrictUniversalPropertyFixedTarget.lift
code: /-- The functor `Localization W ⥤ E` that is induced by a functor `C ⥤ E` which inverts `W`,
when `W` has a left calculus of fractions. -/
noncomputable def lift (F : C ⥤ E) (hF : W.IsInvertedBy F) :
    Localization W ⥤ E 
goal: CategoryTheory.Functor (CategoryTheory.MorphismProperty.LeftFraction.Localization W) E

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.StrictUniversalPropertyFixedTarget.fac
code: lemma fac (F : C ⥤ E) (hF : W.IsInvertedBy F) : Q W ⋙ lift F hF = F 
goal: (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).comp
    (CategoryTheory.MorphismProperty.LeftFraction.Localization.StrictUniversalPropertyFixedTarget.lift F hF) =
  F

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.StrictUniversalPropertyFixedTarget.uniq
code: lemma uniq (F₁ F₂ : Localization W ⥤ E) (h : Q W ⋙ F₁ = Q W ⋙ F₂) : F₁ = F₂ 
goal: F₁ = F₂

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.strictUniversalPropertyFixedTarget
code: /-- The universal property of the localization for the constructed localized category
when there is a left calculus of fractions. -/
noncomputable def strictUniversalPropertyFixedTarget (E : Type*) [Category E] :
    Localization.StrictUniversalPropertyFixedTarget (Q W) W E 
goal: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget
  (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W) W E

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.instIsLocalizationQ
code: instance : (Q W).IsLocalization W 
goal: (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).IsLocalization W

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk_eq
code: lemma homMk_eq {X Y : C} (f : LeftFraction W X Y) :
    homMk f = f.map (Q W) (Localization.inverts _ W) 
goal: CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk f =
  f.map (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W) ⋯

full_name: CategoryTheory.MorphismProperty.LeftFraction.Localization.map_eq_iff
code: lemma map_eq_iff {X Y : C} (f g : LeftFraction W X Y) :
    f.map (LeftFraction.Localization.Q W) (Localization.inverts _ _) =
        g.map (LeftFraction.Localization.Q W) (Localization.inverts _ _) ↔
      LeftFractionRel f g 
goal: f.map (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W) ⋯ =
    g.map (CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W) ⋯ ↔
  CategoryTheory.MorphismProperty.LeftFractionRel f g

full_name: CategoryTheory.MorphismProperty.LeftFraction.map_eq
code: lemma map_eq {X Y : C} (φ : W.LeftFraction X Y) (L : C ⥤ D) [L.IsLocalization W] :
    φ.map L (Localization.inverts L W) =
      L.map φ.f ≫ (Localization.isoOfHom L W φ.s φ.hs).inv 
goal: φ.map L ⋯ = CategoryTheory.CategoryStruct.comp (L.map φ.f) (CategoryTheory.Localization.isoOfHom L W φ.s ⋯).inv

full_name: CategoryTheory.MorphismProperty.LeftFraction.map_compatibility
code: lemma map_compatibility {X Y : C}
    (φ : W.LeftFraction X Y) {E : Type*} [Category E]
    (L₁ : C ⥤ D) (L₂ : C ⥤ E) [L₁.IsLocalization W] [L₂.IsLocalization W] :
    (Localization.uniq L₁ L₂ W).functor.map (φ.map L₁ (Localization.inverts L₁ W)) =
      (Localization.compUniqFunctor L₁ L₂ W).hom.app X ≫
        φ.map L₂ (Localization.inverts L₂ W) ≫
        (Localization.compUniqFunctor L₁ L₂ W).inv.app Y 
goal: (CategoryTheory.Localization.uniq L₁ L₂ W).functor.map (φ.map L₁ ⋯) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.Localization.compUniqFunctor L₁ L₂ W).hom.app X)
    (CategoryTheory.CategoryStruct.comp (φ.map L₂ ⋯) ((CategoryTheory.Localization.compUniqFunctor L₁ L₂ W).inv.app Y))

full_name: CategoryTheory.MorphismProperty.LeftFraction.map_eq_of_map_eq
code: lemma map_eq_of_map_eq {X Y : C}
    (φ₁ φ₂ : W.LeftFraction X Y) {E : Type*} [Category E]
    (L₁ : C ⥤ D) (L₂ : C ⥤ E) [L₁.IsLocalization W] [L₂.IsLocalization W]
    (h : φ₁.map L₁ (Localization.inverts L₁ W) = φ₂.map L₁ (Localization.inverts L₁ W)) :
    φ₁.map L₂ (Localization.inverts L₂ W) = φ₂.map L₂ (Localization.inverts L₂ W) 
goal: φ₁.map L₂ ⋯ = φ₂.map L₂ ⋯

full_name: CategoryTheory.MorphismProperty.LeftFraction.map_comp_map_eq_map
code: lemma map_comp_map_eq_map {X Y Z : C} (z₁ : W.LeftFraction X Y) (z₂ : W.LeftFraction Y Z)
    (z₃ : W.LeftFraction z₁.Y' z₂.Y') (h₃ : z₂.f ≫ z₃.s = z₁.s ≫ z₃.f)
    (L : C ⥤ D) [L.IsLocalization W] :
    z₁.map L (Localization.inverts L W) ≫ z₂.map L (Localization.inverts L W) =
      (z₁.comp₀ z₂ z₃).map L (Localization.inverts L W) 
goal: CategoryTheory.CategoryStruct.comp (z₁.map L ⋯) (z₂.map L ⋯) = (z₁.comp₀ z₂ z₃).map L ⋯

full_name: CategoryTheory.Localization.exists_leftFraction
code: lemma Localization.exists_leftFraction {X Y : C} (f : L.obj X ⟶ L.obj Y) :
    ∃ (φ : W.LeftFraction X Y), f = φ.map L (Localization.inverts L W) 
goal: ∃ φ, f = φ.map L ⋯

full_name: CategoryTheory.MorphismProperty.LeftFraction.map_eq_iff
code: lemma MorphismProperty.LeftFraction.map_eq_iff
    {X Y : C} (φ ψ : W.LeftFraction X Y) :
    φ.map L (Localization.inverts _ _) = ψ.map L (Localization.inverts _ _) ↔
      LeftFractionRel φ ψ 
goal: φ.map L ⋯ = ψ.map L ⋯ ↔ CategoryTheory.MorphismProperty.LeftFractionRel φ ψ

full_name: CategoryTheory.MorphismProperty.map_eq_iff_postcomp
code: lemma MorphismProperty.map_eq_iff_postcomp {X Y : C} (f₁ f₂ : X ⟶ Y) :
    L.map f₁ = L.map f₂ ↔ ∃ (Z : C) (s : Y ⟶ Z) (_ : W s), f₁ ≫ s = f₂ ≫ s 
goal: L.map f₁ = L.map f₂ ↔
  ∃ Z s, ∃ (_ : W s), CategoryTheory.CategoryStruct.comp f₁ s = CategoryTheory.CategoryStruct.comp f₂ s

full_name: CategoryTheory.Localization.essSurj_mapArrow
code: lemma Localization.essSurj_mapArrow :
    L.mapArrow.EssSurj 
goal: L.mapArrow.EssSurj

full_name: CategoryTheory.MorphismProperty.LeftFraction.op_f
code: /-- The right fraction in the opposite category corresponding to a left fraction. -/
@[simps]
def LeftFraction.op {X Y : C} (φ : W.LeftFraction X Y) :
    W.op.RightFraction (Opposite.op Y) (Opposite.op X) 
goal: φ.op.f = φ.f.op

full_name: CategoryTheory.MorphismProperty.LeftFraction.op_X'
code: /-- The right fraction in the opposite category corresponding to a left fraction. -/
@[simps]
def LeftFraction.op {X Y : C} (φ : W.LeftFraction X Y) :
    W.op.RightFraction (Opposite.op Y) (Opposite.op X) 
goal: φ.op.X' = Opposite.op φ.Y'

full_name: CategoryTheory.MorphismProperty.LeftFraction.op
code: /-- The right fraction in the opposite category corresponding to a left fraction. -/
@[simps]
def LeftFraction.op {X Y : C} (φ : W.LeftFraction X Y) :
    W.op.RightFraction (Opposite.op Y) (Opposite.op X) 
goal: W.op.RightFraction (Opposite.op Y) (Opposite.op X)

full_name: CategoryTheory.MorphismProperty.LeftFraction.op_s
code: /-- The right fraction in the opposite category corresponding to a left fraction. -/
@[simps]
def LeftFraction.op {X Y : C} (φ : W.LeftFraction X Y) :
    W.op.RightFraction (Opposite.op Y) (Opposite.op X) 
goal: φ.op.s = φ.s.op

full_name: CategoryTheory.MorphismProperty.RightFraction.op
code: /-- The left fraction in the opposite category corresponding to a right fraction. -/
@[simps]
def RightFraction.op {X Y : C} (φ : W.RightFraction X Y) :
    W.op.LeftFraction (Opposite.op Y) (Opposite.op X) 
goal: W.op.LeftFraction (Opposite.op Y) (Opposite.op X)

full_name: CategoryTheory.MorphismProperty.RightFraction.op_s
code: /-- The left fraction in the opposite category corresponding to a right fraction. -/
@[simps]
def RightFraction.op {X Y : C} (φ : W.RightFraction X Y) :
    W.op.LeftFraction (Opposite.op Y) (Opposite.op X) 
goal: φ.op.s = φ.s.op

full_name: CategoryTheory.MorphismProperty.RightFraction.op_Y'
code: /-- The left fraction in the opposite category corresponding to a right fraction. -/
@[simps]
def RightFraction.op {X Y : C} (φ : W.RightFraction X Y) :
    W.op.LeftFraction (Opposite.op Y) (Opposite.op X) 
goal: φ.op.Y' = Opposite.op φ.X'

full_name: CategoryTheory.MorphismProperty.RightFraction.op_f
code: /-- The left fraction in the opposite category corresponding to a right fraction. -/
@[simps]
def RightFraction.op {X Y : C} (φ : W.RightFraction X Y) :
    W.op.LeftFraction (Opposite.op Y) (Opposite.op X) 
goal: φ.op.f = φ.f.op

full_name: CategoryTheory.MorphismProperty.LeftFraction.unop_f
code: /-- The right fraction corresponding to a left fraction in the opposite category. -/
@[simps]
def LeftFraction.unop {W : MorphismProperty Cᵒᵖ}
    {X Y : Cᵒᵖ} (φ : W.LeftFraction X Y) :
    W.unop.RightFraction (Opposite.unop Y) (Opposite.unop X) 
goal: φ.unop.f = φ.f.unop

full_name: CategoryTheory.MorphismProperty.LeftFraction.unop
code: /-- The right fraction corresponding to a left fraction in the opposite category. -/
@[simps]
def LeftFraction.unop {W : MorphismProperty Cᵒᵖ}
    {X Y : Cᵒᵖ} (φ : W.LeftFraction X Y) :
    W.unop.RightFraction (Opposite.unop Y) (Opposite.unop X) 
goal: W.unop.RightFraction (Opposite.unop Y) (Opposite.unop X)

full_name: CategoryTheory.MorphismProperty.LeftFraction.unop_s
code: /-- The right fraction corresponding to a left fraction in the opposite category. -/
@[simps]
def LeftFraction.unop {W : MorphismProperty Cᵒᵖ}
    {X Y : Cᵒᵖ} (φ : W.LeftFraction X Y) :
    W.unop.RightFraction (Opposite.unop Y) (Opposite.unop X) 
goal: φ.unop.s = φ.s.unop

full_name: CategoryTheory.MorphismProperty.LeftFraction.unop_X'
code: /-- The right fraction corresponding to a left fraction in the opposite category. -/
@[simps]
def LeftFraction.unop {W : MorphismProperty Cᵒᵖ}
    {X Y : Cᵒᵖ} (φ : W.LeftFraction X Y) :
    W.unop.RightFraction (Opposite.unop Y) (Opposite.unop X) 
goal: φ.unop.X' = Opposite.unop φ.Y'

full_name: CategoryTheory.MorphismProperty.RightFraction.unop_f
code: /-- The left fraction corresponding to a right fraction in the opposite category. -/
@[simps]
def RightFraction.unop {W : MorphismProperty Cᵒᵖ}
    {X Y : Cᵒᵖ} (φ : W.RightFraction X Y) :
    W.unop.LeftFraction (Opposite.unop Y) (Opposite.unop X) 
goal: φ.unop.f = φ.f.unop

full_name: CategoryTheory.MorphismProperty.RightFraction.unop_s
code: /-- The left fraction corresponding to a right fraction in the opposite category. -/
@[simps]
def RightFraction.unop {W : MorphismProperty Cᵒᵖ}
    {X Y : Cᵒᵖ} (φ : W.RightFraction X Y) :
    W.unop.LeftFraction (Opposite.unop Y) (Opposite.unop X) 
goal: φ.unop.s = φ.s.unop

full_name: CategoryTheory.MorphismProperty.RightFraction.unop
code: /-- The left fraction corresponding to a right fraction in the opposite category. -/
@[simps]
def RightFraction.unop {W : MorphismProperty Cᵒᵖ}
    {X Y : Cᵒᵖ} (φ : W.RightFraction X Y) :
    W.unop.LeftFraction (Opposite.unop Y) (Opposite.unop X) 
goal: W.unop.LeftFraction (Opposite.unop Y) (Opposite.unop X)

full_name: CategoryTheory.MorphismProperty.RightFraction.unop_Y'
code: /-- The left fraction corresponding to a right fraction in the opposite category. -/
@[simps]
def RightFraction.unop {W : MorphismProperty Cᵒᵖ}
    {X Y : Cᵒᵖ} (φ : W.RightFraction X Y) :
    W.unop.LeftFraction (Opposite.unop Y) (Opposite.unop X) 
goal: φ.unop.Y' = Opposite.unop φ.X'

full_name: CategoryTheory.MorphismProperty.RightFraction.op_map
code: lemma RightFraction.op_map
    {X Y : C} (φ : W.RightFraction X Y) (L : C ⥤ D) (hL : W.IsInvertedBy L) :
    (φ.map L hL).op = φ.op.map L.op hL.op 
goal: (φ.map L hL).op = φ.op.map L.op ⋯

full_name: CategoryTheory.MorphismProperty.LeftFraction.op_map
code: lemma LeftFraction.op_map
    {X Y : C} (φ : W.LeftFraction X Y) (L : C ⥤ D) (hL : W.IsInvertedBy L) :
    (φ.map L hL).op = φ.op.map L.op hL.op 
goal: (φ.map L hL).op = φ.op.map L.op ⋯

full_name: CategoryTheory.MorphismProperty.instHasRightCalculusOfFractionsOppositeOpOfHasLeftCalculusOfFractions
code: instance [h : W.HasLeftCalculusOfFractions] : W.op.HasRightCalculusOfFractions 
goal: W.op.HasRightCalculusOfFractions

full_name: CategoryTheory.MorphismProperty.instHasLeftCalculusOfFractionsOppositeOpOfHasRightCalculusOfFractions
code: instance [h : W.HasRightCalculusOfFractions] : W.op.HasLeftCalculusOfFractions 
goal: W.op.HasLeftCalculusOfFractions

full_name: CategoryTheory.MorphismProperty.instHasRightCalculusOfFractionsUnopOfHasLeftCalculusOfFractionsOpposite
code: instance (W : MorphismProperty Cᵒᵖ) [h : W.HasLeftCalculusOfFractions] :
    W.unop.HasRightCalculusOfFractions 
goal: W.unop.HasRightCalculusOfFractions

full_name: CategoryTheory.MorphismProperty.instHasLeftCalculusOfFractionsUnopOfHasRightCalculusOfFractionsOpposite
code: instance (W : MorphismProperty Cᵒᵖ) [h : W.HasRightCalculusOfFractions] :
    W.unop.HasLeftCalculusOfFractions 
goal: W.unop.HasLeftCalculusOfFractions

full_name: CategoryTheory.MorphismProperty.RightFractionRel
code: /-- The equivalence relation on right fractions for a morphism property `W`. -/
def RightFractionRel {X Y : C} (z₁ z₂ : W.RightFraction X Y) : Prop 
goal: Prop

full_name: CategoryTheory.MorphismProperty.RightFractionRel.op
code: lemma RightFractionRel.op {X Y : C} {z₁ z₂ : W.RightFraction X Y}
    (h : RightFractionRel z₁ z₂) : LeftFractionRel z₁.op z₂.op 
goal: CategoryTheory.MorphismProperty.LeftFractionRel z₁.op z₂.op

full_name: CategoryTheory.MorphismProperty.RightFractionRel.unop
code: lemma RightFractionRel.unop {W : MorphismProperty Cᵒᵖ} {X Y : Cᵒᵖ}
    {z₁ z₂ : W.RightFraction X Y}
    (h : RightFractionRel z₁ z₂) : LeftFractionRel z₁.unop z₂.unop 
goal: CategoryTheory.MorphismProperty.LeftFractionRel z₁.unop z₂.unop

full_name: CategoryTheory.MorphismProperty.LeftFractionRel.op
code: lemma LeftFractionRel.op {X Y : C} {z₁ z₂ : W.LeftFraction X Y}
    (h : LeftFractionRel z₁ z₂) : RightFractionRel z₁.op z₂.op 
goal: CategoryTheory.MorphismProperty.RightFractionRel z₁.op z₂.op

full_name: CategoryTheory.MorphismProperty.LeftFractionRel.unop
code: lemma LeftFractionRel.unop {W : MorphismProperty Cᵒᵖ} {X Y : Cᵒᵖ}
    {z₁ z₂ : W.LeftFraction X Y}
    (h : LeftFractionRel z₁ z₂) : RightFractionRel z₁.unop z₂.unop 
goal: CategoryTheory.MorphismProperty.RightFractionRel z₁.unop z₂.unop

full_name: CategoryTheory.MorphismProperty.leftFractionRel_op_iff
code: lemma leftFractionRel_op_iff
    {X Y : C} (z₁ z₂ : W.RightFraction X Y) :
    LeftFractionRel z₁.op z₂.op ↔ RightFractionRel z₁ z₂ 
goal: CategoryTheory.MorphismProperty.LeftFractionRel z₁.op z₂.op ↔ CategoryTheory.MorphismProperty.RightFractionRel z₁ z₂

full_name: CategoryTheory.MorphismProperty.rightFractionRel_op_iff
code: lemma rightFractionRel_op_iff
    {X Y : C} (z₁ z₂ : W.LeftFraction X Y) :
    RightFractionRel z₁.op z₂.op ↔ LeftFractionRel z₁ z₂ 
goal: CategoryTheory.MorphismProperty.RightFractionRel z₁.op z₂.op ↔ CategoryTheory.MorphismProperty.LeftFractionRel z₁ z₂

full_name: CategoryTheory.MorphismProperty.RightFractionRel.refl
code: lemma refl {X Y : C} (z : W.RightFraction X Y) : RightFractionRel z z 
goal: CategoryTheory.MorphismProperty.RightFractionRel z z

full_name: CategoryTheory.MorphismProperty.RightFractionRel.symm
code: lemma symm {X Y : C} {z₁ z₂ : W.RightFraction X Y} (h : RightFractionRel z₁ z₂) :
    RightFractionRel z₂ z₁ 
goal: CategoryTheory.MorphismProperty.RightFractionRel z₂ z₁

full_name: CategoryTheory.MorphismProperty.RightFractionRel.trans
code: lemma trans {X Y : C} {z₁ z₂ z₃ : W.RightFraction X Y}
    [HasRightCalculusOfFractions W]
    (h₁₂ : RightFractionRel z₁ z₂) (h₂₃ : RightFractionRel z₂ z₃) :
    RightFractionRel z₁ z₃ 
goal: CategoryTheory.MorphismProperty.RightFractionRel z₁ z₃

full_name: CategoryTheory.MorphismProperty.equivalenceRightFractionRel
code: lemma equivalenceRightFractionRel (X Y : C) [HasRightCalculusOfFractions W] :
    @_root_.Equivalence (W.RightFraction X Y) RightFractionRel 
goal: Equivalence CategoryTheory.MorphismProperty.RightFractionRel

full_name: CategoryTheory.Localization.exists_rightFraction
code: lemma Localization.exists_rightFraction {X Y : C} (f : L.obj X ⟶ L.obj Y) :
    ∃ (φ : W.RightFraction X Y), f = φ.map L (Localization.inverts L W) 
goal: ∃ φ, f = φ.map L ⋯

full_name: CategoryTheory.MorphismProperty.RightFraction.map_eq_iff
code: lemma MorphismProperty.RightFraction.map_eq_iff
    {X Y : C} (φ ψ : W.RightFraction X Y) :
    φ.map L (Localization.inverts _ _) = ψ.map L (Localization.inverts _ _) ↔
      RightFractionRel φ ψ 
goal: φ.map L ⋯ = ψ.map L ⋯ ↔ CategoryTheory.MorphismProperty.RightFractionRel φ ψ

full_name: CategoryTheory.MorphismProperty.map_eq_iff_precomp
code: lemma MorphismProperty.map_eq_iff_precomp {Y Z : C} (f₁ f₂ : Y ⟶ Z) :
    L.map f₁ = L.map f₂ ↔ ∃ (X : C) (s : X ⟶ Y) (_ : W s), s ≫ f₁ = s ≫ f₂ 
goal: L.map f₁ = L.map f₂ ↔
  ∃ X s, ∃ (_ : W s), CategoryTheory.CategoryStruct.comp s f₁ = CategoryTheory.CategoryStruct.comp s f₂

full_name: CategoryTheory.Localization.essSurj_mapArrow_of_hasRightCalculusOfFractions
code: lemma Localization.essSurj_mapArrow_of_hasRightCalculusOfFractions :
    L.mapArrow.EssSurj 
goal: L.mapArrow.EssSurj