[GOAL]
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
⊢ IsConformalMap (restrictScalars ℝ map)
[PROOFSTEP]
have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
[GOAL]
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
⊢ ‖↑map 1‖ ≠ 0
[PROOFSTEP]
simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
[GOAL]
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖↑map 1‖ ≠ 0
⊢ IsConformalMap (restrictScalars ℝ map)
[PROOFSTEP]
refine' ⟨‖map 1‖, minor₁, ⟨‖map 1‖⁻¹ • ((map : ℂ →ₗ[ℂ] E) : ℂ →ₗ[ℝ] E), _⟩, _⟩
[GOAL]
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖↑map 1‖ ≠ 0
⊢ ∀ (x : ℂ), ‖↑(‖↑map 1‖⁻¹ • ↑ℝ ↑map) x‖ = ‖x‖
[PROOFSTEP]
intro x
[GOAL]
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖↑map 1‖ ≠ 0
x : ℂ
⊢ ‖↑(‖↑map 1‖⁻¹ • ↑ℝ ↑map) x‖ = ‖x‖
[PROOFSTEP]
simp only [LinearMap.smul_apply]
[GOAL]
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖↑map 1‖ ≠ 0
x : ℂ
⊢ ‖‖↑map 1‖⁻¹ • ↑(↑ℝ ↑map) x‖ = ‖x‖
[PROOFSTEP]
have : x = x • (1 : ℂ) := by rw [smul_eq_mul, mul_one]
[GOAL]
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖↑map 1‖ ≠ 0
x : ℂ
⊢ x = x • 1
[PROOFSTEP]
rw [smul_eq_mul, mul_one]
[GOAL]
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖↑map 1‖ ≠ 0
x : ℂ
this : x = x • 1
⊢ ‖‖↑map 1‖⁻¹ • ↑(↑ℝ ↑map) x‖ = ‖x‖
[PROOFSTEP]
nth_rw 1 [this]
[GOAL]
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖↑map 1‖ ≠ 0
x : ℂ
this : x = x • 1
⊢ ‖‖↑map 1‖⁻¹ • ↑(↑ℝ ↑map) (x • 1)‖ = ‖x‖
[PROOFSTEP]
rw [LinearMap.coe_restrictScalars]
[GOAL]
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖↑map 1‖ ≠ 0
x : ℂ
this : x = x • 1
⊢ ‖‖↑map 1‖⁻¹ • ↑↑map (x • 1)‖ = ‖x‖
[PROOFSTEP]
simp only [map.coe_coe, map.map_smul, norm_smul, norm_inv, norm_norm]
[GOAL]
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖↑map 1‖ ≠ 0
x : ℂ
this : x = x • 1
⊢ ‖↑map 1‖⁻¹ * (‖x‖ * ‖↑map 1‖) = ‖x‖
[PROOFSTEP]
field_simp only [one_mul]
[GOAL]
case refine'_2
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖↑map 1‖ ≠ 0
⊢ restrictScalars ℝ map =
    ‖↑map 1‖ •
      LinearIsometry.toContinuousLinearMap
        { toLinearMap := ‖↑map 1‖⁻¹ • ↑ℝ ↑map, norm_map' := (_ : ∀ (x : ℂ), ‖↑(‖↑map 1‖⁻¹ • ↑ℝ ↑map) x‖ = ‖x‖) }
[PROOFSTEP]
ext1
  -- Porting note: was simp
[GOAL]
case refine'_2.h
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖↑map 1‖ ≠ 0
x✝ : ℂ
⊢ ↑(restrictScalars ℝ map) x✝ =
    ↑(‖↑map 1‖ •
          LinearIsometry.toContinuousLinearMap
            { toLinearMap := ‖↑map 1‖⁻¹ • ↑ℝ ↑map, norm_map' := (_ : ∀ (x : ℂ), ‖↑(‖↑map 1‖⁻¹ • ↑ℝ ↑map) x‖ = ‖x‖) })
      x✝
[PROOFSTEP]
rw [coe_restrictScalars', coe_smul', LinearIsometry.coe_toContinuousLinearMap, LinearIsometry.coe_mk, Pi.smul_apply,
  LinearMap.smul_apply, LinearMap.coe_restrictScalars, coe_coe, smul_inv_smul₀ minor₁]
[GOAL]
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
h : IsConformalMap g
⊢ (∃ map, restrictScalars ℝ map = g) ∨ ∃ map, restrictScalars ℝ map = ContinuousLinearMap.comp g ↑conjCle
[PROOFSTEP]
rcases h with ⟨c, -, li, rfl⟩
[GOAL]
case intro.intro.intro
f : ℂ → ℂ
z : ℂ
c : ℝ
li : ℂ →ₗᵢ[ℝ] ℂ
⊢ (∃ map, restrictScalars ℝ map = c • LinearIsometry.toContinuousLinearMap li) ∨
    ∃ map, restrictScalars ℝ map = ContinuousLinearMap.comp (c • LinearIsometry.toContinuousLinearMap li) ↑conjCle
[PROOFSTEP]
obtain ⟨li, rfl⟩ : ∃ li' : ℂ ≃ₗᵢ[ℝ] ℂ, li'.toLinearIsometry = li := ⟨li.toLinearIsometryEquiv rfl, by ext1; rfl⟩
[GOAL]
f : ℂ → ℂ
z : ℂ
c : ℝ
li : ℂ →ₗᵢ[ℝ] ℂ
⊢ LinearIsometryEquiv.toLinearIsometry
      (LinearIsometry.toLinearIsometryEquiv li (_ : FiniteDimensional.finrank ℝ ℂ = FiniteDimensional.finrank ℝ ℂ)) =
    li
[PROOFSTEP]
ext1
[GOAL]
case h
f : ℂ → ℂ
z : ℂ
c : ℝ
li : ℂ →ₗᵢ[ℝ] ℂ
x✝ : ℂ
⊢ ↑(LinearIsometryEquiv.toLinearIsometry
          (LinearIsometry.toLinearIsometryEquiv li (_ : FiniteDimensional.finrank ℝ ℂ = FiniteDimensional.finrank ℝ ℂ)))
      x✝ =
    ↑li x✝
[PROOFSTEP]
rfl
[GOAL]
case intro.intro.intro.intro
f : ℂ → ℂ
z : ℂ
c : ℝ
li : ℂ ≃ₗᵢ[ℝ] ℂ
⊢ (∃ map, restrictScalars ℝ map = c • LinearIsometry.toContinuousLinearMap (LinearIsometryEquiv.toLinearIsometry li)) ∨
    ∃ map,
      restrictScalars ℝ map =
        ContinuousLinearMap.comp (c • LinearIsometry.toContinuousLinearMap (LinearIsometryEquiv.toLinearIsometry li))
          ↑conjCle
[PROOFSTEP]
rcases linear_isometry_complex li with
  ⟨a, rfl | rfl⟩
    -- let rot := c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ,
[GOAL]
case intro.intro.intro.intro.intro.inl
f : ℂ → ℂ
z : ℂ
c : ℝ
a : { x // x ∈ circle }
⊢ (∃ map,
      restrictScalars ℝ map =
        c • LinearIsometry.toContinuousLinearMap (LinearIsometryEquiv.toLinearIsometry (↑rotation a))) ∨
    ∃ map,
      restrictScalars ℝ map =
        ContinuousLinearMap.comp
          (c • LinearIsometry.toContinuousLinearMap (LinearIsometryEquiv.toLinearIsometry (↑rotation a))) ↑conjCle
[PROOFSTEP]
refine' Or.inl ⟨c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ, _⟩
[GOAL]
case intro.intro.intro.intro.intro.inl
f : ℂ → ℂ
z : ℂ
c : ℝ
a : { x // x ∈ circle }
⊢ restrictScalars ℝ (c • ↑a • ContinuousLinearMap.id ℂ ℂ) =
    c • LinearIsometry.toContinuousLinearMap (LinearIsometryEquiv.toLinearIsometry (↑rotation a))
[PROOFSTEP]
ext1
  -- Porting note: was simp
[GOAL]
case intro.intro.intro.intro.intro.inl.h
f : ℂ → ℂ
z : ℂ
c : ℝ
a : { x // x ∈ circle }
x✝ : ℂ
⊢ ↑(restrictScalars ℝ (c • ↑a • ContinuousLinearMap.id ℂ ℂ)) x✝ =
    ↑(c • LinearIsometry.toContinuousLinearMap (LinearIsometryEquiv.toLinearIsometry (↑rotation a))) x✝
[PROOFSTEP]
rw [coe_restrictScalars', smul_apply, smul_apply, smul_apply, LinearIsometry.coe_toContinuousLinearMap,
  LinearIsometryEquiv.coe_toLinearIsometry, rotation_apply, id_apply, smul_eq_mul]
[GOAL]
case intro.intro.intro.intro.intro.inr
f : ℂ → ℂ
z : ℂ
c : ℝ
a : { x // x ∈ circle }
⊢ (∃ map,
      restrictScalars ℝ map =
        c •
          LinearIsometry.toContinuousLinearMap
            (LinearIsometryEquiv.toLinearIsometry (LinearIsometryEquiv.trans conjLie (↑rotation a)))) ∨
    ∃ map,
      restrictScalars ℝ map =
        ContinuousLinearMap.comp
          (c •
            LinearIsometry.toContinuousLinearMap
              (LinearIsometryEquiv.toLinearIsometry (LinearIsometryEquiv.trans conjLie (↑rotation a))))
          ↑conjCle
[PROOFSTEP]
refine' Or.inr ⟨c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ, _⟩
[GOAL]
case intro.intro.intro.intro.intro.inr
f : ℂ → ℂ
z : ℂ
c : ℝ
a : { x // x ∈ circle }
⊢ restrictScalars ℝ (c • ↑a • ContinuousLinearMap.id ℂ ℂ) =
    ContinuousLinearMap.comp
      (c •
        LinearIsometry.toContinuousLinearMap
          (LinearIsometryEquiv.toLinearIsometry (LinearIsometryEquiv.trans conjLie (↑rotation a))))
      ↑conjCle
[PROOFSTEP]
ext1
  -- Porting note: was simp
[GOAL]
case intro.intro.intro.intro.intro.inr.h
f : ℂ → ℂ
z : ℂ
c : ℝ
a : { x // x ∈ circle }
x✝ : ℂ
⊢ ↑(restrictScalars ℝ (c • ↑a • ContinuousLinearMap.id ℂ ℂ)) x✝ =
    ↑(ContinuousLinearMap.comp
          (c •
            LinearIsometry.toContinuousLinearMap
              (LinearIsometryEquiv.toLinearIsometry (LinearIsometryEquiv.trans conjLie (↑rotation a))))
          ↑conjCle)
      x✝
[PROOFSTEP]
rw [coe_restrictScalars', smul_apply, smul_apply, comp_apply, smul_apply, LinearIsometry.coe_toContinuousLinearMap,
  LinearIsometryEquiv.coe_toLinearIsometry, LinearIsometryEquiv.trans_apply, rotation_apply, id_apply, smul_eq_mul,
  ContinuousLinearEquiv.coe_coe, conjCle_apply, conjLie_apply, conj_conj]
[GOAL]
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
⊢ IsConformalMap g ↔ ((∃ map, restrictScalars ℝ map = g) ∨ ∃ map, restrictScalars ℝ map = comp g ↑conjCle) ∧ g ≠ 0
[PROOFSTEP]
constructor
[GOAL]
case mp
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
⊢ IsConformalMap g → ((∃ map, restrictScalars ℝ map = g) ∨ ∃ map, restrictScalars ℝ map = comp g ↑conjCle) ∧ g ≠ 0
[PROOFSTEP]
exact fun h => ⟨h.is_complex_or_conj_linear, h.ne_zero⟩
[GOAL]
case mpr
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
⊢ ((∃ map, restrictScalars ℝ map = g) ∨ ∃ map, restrictScalars ℝ map = comp g ↑conjCle) ∧ g ≠ 0 → IsConformalMap g
[PROOFSTEP]
rintro ⟨⟨map, rfl⟩ | ⟨map, hmap⟩, h₂⟩
[GOAL]
case mpr.intro.inl.intro
f : ℂ → ℂ
z : ℂ
map : ℂ →L[ℂ] ℂ
h₂ : restrictScalars ℝ map ≠ 0
⊢ IsConformalMap (restrictScalars ℝ map)
[PROOFSTEP]
refine' isConformalMap_complex_linear _
[GOAL]
case mpr.intro.inl.intro
f : ℂ → ℂ
z : ℂ
map : ℂ →L[ℂ] ℂ
h₂ : restrictScalars ℝ map ≠ 0
⊢ map ≠ 0
[PROOFSTEP]
contrapose! h₂ with w
[GOAL]
case mpr.intro.inl.intro
f : ℂ → ℂ
z : ℂ
map : ℂ →L[ℂ] ℂ
w : map = 0
⊢ restrictScalars ℝ map = 0
[PROOFSTEP]
simp only [w, restrictScalars_zero]
[GOAL]
case mpr.intro.inr.intro
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
h₂ : g ≠ 0
map : ℂ →L[ℂ] ℂ
hmap : restrictScalars ℝ map = comp g ↑conjCle
⊢ IsConformalMap g
[PROOFSTEP]
have minor₁ : g = map.restrictScalars ℝ ∘L ↑conjCle := by
  ext1
  simp only [hmap, coe_comp', ContinuousLinearEquiv.coe_coe, Function.comp_apply, conjCle_apply, starRingEnd_self_apply]
[GOAL]
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
h₂ : g ≠ 0
map : ℂ →L[ℂ] ℂ
hmap : restrictScalars ℝ map = comp g ↑conjCle
⊢ g = comp (restrictScalars ℝ map) ↑conjCle
[PROOFSTEP]
ext1
[GOAL]
case h
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
h₂ : g ≠ 0
map : ℂ →L[ℂ] ℂ
hmap : restrictScalars ℝ map = comp g ↑conjCle
x✝ : ℂ
⊢ ↑g x✝ = ↑(comp (restrictScalars ℝ map) ↑conjCle) x✝
[PROOFSTEP]
simp only [hmap, coe_comp', ContinuousLinearEquiv.coe_coe, Function.comp_apply, conjCle_apply, starRingEnd_self_apply]
[GOAL]
case mpr.intro.inr.intro
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
h₂ : g ≠ 0
map : ℂ →L[ℂ] ℂ
hmap : restrictScalars ℝ map = comp g ↑conjCle
minor₁ : g = comp (restrictScalars ℝ map) ↑conjCle
⊢ IsConformalMap g
[PROOFSTEP]
rw [minor₁] at h₂ ⊢
[GOAL]
case mpr.intro.inr.intro
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
map : ℂ →L[ℂ] ℂ
h₂ : comp (restrictScalars ℝ map) ↑conjCle ≠ 0
hmap : restrictScalars ℝ map = comp g ↑conjCle
minor₁ : g = comp (restrictScalars ℝ map) ↑conjCle
⊢ IsConformalMap (comp (restrictScalars ℝ map) ↑conjCle)
[PROOFSTEP]
refine' isConformalMap_complex_linear_conj _
[GOAL]
case mpr.intro.inr.intro
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
map : ℂ →L[ℂ] ℂ
h₂ : comp (restrictScalars ℝ map) ↑conjCle ≠ 0
hmap : restrictScalars ℝ map = comp g ↑conjCle
minor₁ : g = comp (restrictScalars ℝ map) ↑conjCle
⊢ map ≠ 0
[PROOFSTEP]
contrapose! h₂ with w
[GOAL]
case mpr.intro.inr.intro
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
map : ℂ →L[ℂ] ℂ
hmap : restrictScalars ℝ map = comp g ↑conjCle
minor₁ : g = comp (restrictScalars ℝ map) ↑conjCle
w : map = 0
⊢ comp (restrictScalars ℝ map) ↑conjCle = 0
[PROOFSTEP]
simp only [w, restrictScalars_zero, zero_comp]


[GOAL]
α : Type u_1
inst✝¹ : Group α
inst✝ : HasDistribNeg α
a : α
⊢ (-a)⁻¹ = -a⁻¹
[PROOFSTEP]
rw [eq_comm, eq_inv_iff_mul_eq_one, neg_mul, mul_neg, neg_neg, mul_left_inv]
[GOAL]
α : Type u_1
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
⊢ ∃ y, y * y - b * y + c = 0 ∧ x + y = b ∧ x * y = c
[PROOFSTEP]
have : c = x * (b - x) := (eq_neg_of_add_eq_zero_right h).trans (by simp [mul_sub, mul_comm])
[GOAL]
α : Type u_1
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
⊢ -(x * x - b * x) = x * (b - x)
[PROOFSTEP]
simp [mul_sub, mul_comm]
[GOAL]
α : Type u_1
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
this : c = x * (b - x)
⊢ ∃ y, y * y - b * y + c = 0 ∧ x + y = b ∧ x * y = c
[PROOFSTEP]
refine' ⟨b - x, _, by simp, by rw [this]⟩
[GOAL]
α : Type u_1
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
this : c = x * (b - x)
⊢ x + (b - x) = b
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
this : c = x * (b - x)
⊢ x * (b - x) = c
[PROOFSTEP]
rw [this]
[GOAL]
α : Type u_1
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
this : c = x * (b - x)
⊢ (b - x) * (b - x) - b * (b - x) + c = 0
[PROOFSTEP]
rw [this, sub_add, ← sub_mul, sub_self]
[GOAL]
α : Type u_1
inst✝¹ : NonAssocRing α
inst✝ : Nontrivial α
a : α
h : a + 1 = a
⊢ a + 1 = a + 0
[PROOFSTEP]
simp [h]
[GOAL]
α : Type u_1
inst✝¹ : NonAssocRing α
inst✝ : Nontrivial α
a : α
h : a - 1 = a
⊢ a + -1 = a + -0
[PROOFSTEP]
simp [← sub_eq_add_neg, h]
[GOAL]
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsLeftCancelMulZero α
x y : α
h : x * y = 0
⊢ x = 0 ∨ y = 0
[PROOFSTEP]
by_cases hx : x = 0
[GOAL]
case pos
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsLeftCancelMulZero α
x y : α
h : x * y = 0
hx : x = 0
⊢ x = 0 ∨ y = 0
case neg α : Type u_1 inst✝¹ : Ring α inst✝ : IsLeftCancelMulZero α x y : α h : x * y = 0 hx : ¬x = 0 ⊢ x = 0 ∨ y = 0
[PROOFSTEP]
{ left
  exact hx
}
[GOAL]
case pos
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsLeftCancelMulZero α
x y : α
h : x * y = 0
hx : x = 0
⊢ x = 0 ∨ y = 0
[PROOFSTEP]
left
[GOAL]
case pos.h
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsLeftCancelMulZero α
x y : α
h : x * y = 0
hx : x = 0
⊢ x = 0
[PROOFSTEP]
exact hx
[GOAL]
case neg
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsLeftCancelMulZero α
x y : α
h : x * y = 0
hx : ¬x = 0
⊢ x = 0 ∨ y = 0
[PROOFSTEP]
{ right
  rw [← sub_zero (x * y), ← mul_zero x, ← mul_sub] at h
  have := (IsLeftCancelMulZero.mul_left_cancel_of_ne_zero) hx h
  rwa [sub_zero] at this
}
[GOAL]
case neg
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsLeftCancelMulZero α
x y : α
h : x * y = 0
hx : ¬x = 0
⊢ x = 0 ∨ y = 0
[PROOFSTEP]
right
[GOAL]
case neg.h
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsLeftCancelMulZero α
x y : α
h : x * y = 0
hx : ¬x = 0
⊢ y = 0
[PROOFSTEP]
rw [← sub_zero (x * y), ← mul_zero x, ← mul_sub] at h
[GOAL]
case neg.h
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsLeftCancelMulZero α
x y : α
h : x * (y - 0) = x * 0
hx : ¬x = 0
⊢ y = 0
[PROOFSTEP]
have := (IsLeftCancelMulZero.mul_left_cancel_of_ne_zero) hx h
[GOAL]
case neg.h
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsLeftCancelMulZero α
x y : α
h : x * (y - 0) = x * 0
hx : ¬x = 0
this : y - 0 = 0
⊢ y = 0
[PROOFSTEP]
rwa [sub_zero] at this
[GOAL]
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsRightCancelMulZero α
x y : α
h : x * y = 0
⊢ x = 0 ∨ y = 0
[PROOFSTEP]
by_cases hy : y = 0
[GOAL]
case pos
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsRightCancelMulZero α
x y : α
h : x * y = 0
hy : y = 0
⊢ x = 0 ∨ y = 0
case neg α : Type u_1 inst✝¹ : Ring α inst✝ : IsRightCancelMulZero α x y : α h : x * y = 0 hy : ¬y = 0 ⊢ x = 0 ∨ y = 0
[PROOFSTEP]
{ right
  exact hy
}
[GOAL]
case pos
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsRightCancelMulZero α
x y : α
h : x * y = 0
hy : y = 0
⊢ x = 0 ∨ y = 0
[PROOFSTEP]
right
[GOAL]
case pos.h
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsRightCancelMulZero α
x y : α
h : x * y = 0
hy : y = 0
⊢ y = 0
[PROOFSTEP]
exact hy
[GOAL]
case neg
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsRightCancelMulZero α
x y : α
h : x * y = 0
hy : ¬y = 0
⊢ x = 0 ∨ y = 0
[PROOFSTEP]
{ left
  rw [← sub_zero (x * y), ← zero_mul y, ← sub_mul] at h
  have := (IsRightCancelMulZero.mul_right_cancel_of_ne_zero) hy h
  rwa [sub_zero] at this
}
[GOAL]
case neg
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsRightCancelMulZero α
x y : α
h : x * y = 0
hy : ¬y = 0
⊢ x = 0 ∨ y = 0
[PROOFSTEP]
left
[GOAL]
case neg.h
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsRightCancelMulZero α
x y : α
h : x * y = 0
hy : ¬y = 0
⊢ x = 0
[PROOFSTEP]
rw [← sub_zero (x * y), ← zero_mul y, ← sub_mul] at h
[GOAL]
case neg.h
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsRightCancelMulZero α
x y : α
h : (x - 0) * y = 0 * y
hy : ¬y = 0
⊢ x = 0
[PROOFSTEP]
have := (IsRightCancelMulZero.mul_right_cancel_of_ne_zero) hy h
[GOAL]
case neg.h
α : Type u_1
inst✝¹ : Ring α
inst✝ : IsRightCancelMulZero α
x y : α
h : (x - 0) * y = 0 * y
hy : ¬y = 0
this : x - 0 = 0
⊢ x = 0
[PROOFSTEP]
rwa [sub_zero] at this
[GOAL]
α : Type ?u.21715
inst✝¹ : Ring α
inst✝ : NoZeroDivisors α
a✝ b✝ c✝ : α
ha : a✝ ≠ 0
h : a✝ * b✝ = a✝ * c✝
⊢ b✝ = c✝
[PROOFSTEP]
rw [← sub_eq_zero, ← mul_sub] at h
[GOAL]
α : Type ?u.21715
inst✝¹ : Ring α
inst✝ : NoZeroDivisors α
a✝ b✝ c✝ : α
ha : a✝ ≠ 0
h✝ : a✝ * b✝ = a✝ * c✝
h : a✝ * (b✝ - c✝) = 0
⊢ b✝ = c✝
[PROOFSTEP]
exact sub_eq_zero.1 ((eq_zero_or_eq_zero_of_mul_eq_zero h).resolve_left ha)
[GOAL]
α : Type ?u.21715
inst✝¹ : Ring α
inst✝ : NoZeroDivisors α
a✝ b✝ c✝ : α
hb : b✝ ≠ 0
h : a✝ * b✝ = c✝ * b✝
⊢ a✝ = c✝
[PROOFSTEP]
rw [← sub_eq_zero, ← sub_mul] at h
[GOAL]
α : Type ?u.21715
inst✝¹ : Ring α
inst✝ : NoZeroDivisors α
a✝ b✝ c✝ : α
hb : b✝ ≠ 0
h✝ : a✝ * b✝ = c✝ * b✝
h : (a✝ - c✝) * b✝ = 0
⊢ a✝ = c✝
[PROOFSTEP]
exact sub_eq_zero.1 ((eq_zero_or_eq_zero_of_mul_eq_zero h).resolve_right hb)


[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : KernelFork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ G.map (Fork.ι c) ≫ G.map f = 0
[PROOFSTEP]
rw [← G.map_comp, c.condition, G.map_zero]
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : KernelFork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ IsLimit (G.mapCone c) ≃ IsLimit (map c G)
[PROOFSTEP]
refine' (IsLimit.postcomposeHomEquiv _ _).symm.trans (IsLimit.equivIsoLimit _)
[GOAL]
case refine'_1
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : KernelFork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ parallelPair f 0 ⋙ G ≅ parallelPair (G.map f) 0
[PROOFSTEP]
refine' parallelPair.ext (Iso.refl _) (Iso.refl _) _ _
[GOAL]
case refine'_1.refine'_1
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : KernelFork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ (parallelPair f 0 ⋙ G).map WalkingParallelPairHom.left ≫
      (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.one)).hom =
    (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.zero)).hom ≫
      (parallelPair (G.map f) 0).map WalkingParallelPairHom.left
[PROOFSTEP]
simp
[GOAL]
case refine'_1.refine'_2
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : KernelFork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ (parallelPair f 0 ⋙ G).map WalkingParallelPairHom.right ≫
      (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.one)).hom =
    (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.zero)).hom ≫
      (parallelPair (G.map f) 0).map WalkingParallelPairHom.right
[PROOFSTEP]
simp
[GOAL]
case refine'_2
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : KernelFork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ (Cones.postcompose
          (parallelPair.ext (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.zero))
              (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.one))
              (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
              (_ : G.map 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ 0)).hom).obj
      (G.mapCone c) ≅
    map c G
[PROOFSTEP]
exact Cones.ext (Iso.refl _) (by rintro (_ | _) <;> aesop_cat)
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : KernelFork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ ∀ (j : WalkingParallelPair),
    NatTrans.app
        ((Cones.postcompose
                (parallelPair.ext (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.zero))
                    (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.one))
                    (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
                    (_ : G.map 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ 0)).hom).obj
            (G.mapCone c)).π
        j =
      (Iso.refl
            ((Cones.postcompose
                    (parallelPair.ext (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.zero))
                        (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.one))
                        (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
                        (_ : G.map 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ 0)).hom).obj
                (G.mapCone c)).pt).hom ≫
        NatTrans.app (map c G).π j
[PROOFSTEP]
rintro (_ | _)
[GOAL]
case zero
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : KernelFork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ NatTrans.app
      ((Cones.postcompose
              (parallelPair.ext (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.zero))
                  (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.one))
                  (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
                  (_ : G.map 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ 0)).hom).obj
          (G.mapCone c)).π
      WalkingParallelPair.zero =
    (Iso.refl
          ((Cones.postcompose
                  (parallelPair.ext (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.zero))
                      (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.one))
                      (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
                      (_ : G.map 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ 0)).hom).obj
              (G.mapCone c)).pt).hom ≫
      NatTrans.app (map c G).π WalkingParallelPair.zero
[PROOFSTEP]
aesop_cat
[GOAL]
case one
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : KernelFork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ NatTrans.app
      ((Cones.postcompose
              (parallelPair.ext (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.zero))
                  (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.one))
                  (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
                  (_ : G.map 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ 0)).hom).obj
          (G.mapCone c)).π
      WalkingParallelPair.one =
    (Iso.refl
          ((Cones.postcompose
                  (parallelPair.ext (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.zero))
                      (Iso.refl ((parallelPair f 0 ⋙ G).obj WalkingParallelPair.one))
                      (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
                      (_ : G.map 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ 0)).hom).obj
              (G.mapCone c)).pt).hom ≫
      NatTrans.app (map c G).π WalkingParallelPair.one
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
⊢ G.map h ≫ G.map f = 0
[PROOFSTEP]
simp only [← G.map_comp, w, Functor.map_zero]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : HasZeroMorphisms C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : HasZeroMorphisms D
G : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝ : PreservesLimit (parallelPair f 0) G
l : IsLimit (KernelFork.ofι h w)
⊢ G.map h ≫ G.map f = 0
[PROOFSTEP]
simp only [← G.map_comp, w, Functor.map_zero]
[GOAL]
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : HasZeroMorphisms C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝¹ : HasKernel f
inst✝ : PreservesLimit (parallelPair f 0) G
⊢ G.map (kernel.ι f) ≫ G.map f = G.map (kernel.ι f) ≫ 0
[PROOFSTEP]
simp only [← G.map_comp, kernel.condition, comp_zero, Functor.map_zero]
[GOAL]
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : HasZeroMorphisms C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝¹ : HasKernel f
inst✝ : HasKernel (G.map f)
i : IsIso (kernelComparison f G)
⊢ PreservesLimit (parallelPair f 0) G
[PROOFSTEP]
apply preservesLimitOfPreservesLimitCone (kernelIsKernel f)
[GOAL]
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : HasZeroMorphisms C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝¹ : HasKernel f
inst✝ : HasKernel (G.map f)
i : IsIso (kernelComparison f G)
⊢ IsLimit (G.mapCone (Fork.ofι (kernel.ι f) (_ : kernel.ι f ≫ f = kernel.ι f ≫ 0)))
[PROOFSTEP]
apply (isLimitMapConeForkEquiv' G (kernel.condition f)).symm _
[GOAL]
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : HasZeroMorphisms C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝¹ : HasKernel f
inst✝ : HasKernel (G.map f)
i : IsIso (kernelComparison f G)
⊢ IsLimit (KernelFork.ofι (G.map (kernel.ι f)) (_ : G.map (kernel.ι f) ≫ G.map f = 0))
[PROOFSTEP]
exact @IsLimit.ofPointIso _ _ _ _ _ _ _ (kernelIsKernel (G.map f)) i
[GOAL]
C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝² : HasKernel f
inst✝¹ : HasKernel (G.map f)
inst✝ : PreservesLimit (parallelPair f 0) G
⊢ (iso G f).hom = kernelComparison f G
[PROOFSTEP]
rw [← cancel_mono (kernel.ι _)]
[GOAL]
C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝² : HasKernel f
inst✝¹ : HasKernel (G.map f)
inst✝ : PreservesLimit (parallelPair f 0) G
⊢ (iso G f).hom ≫ kernel.ι (G.map f) = kernelComparison f G ≫ kernel.ι (G.map f)
[PROOFSTEP]
simp [PreservesKernel.iso]
[GOAL]
C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝² : HasKernel f
inst✝¹ : HasKernel (G.map f)
inst✝ : PreservesLimit (parallelPair f 0) G
⊢ IsIso (kernelComparison f G)
[PROOFSTEP]
rw [← PreservesKernel.iso_hom]
[GOAL]
C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝² : HasKernel f
inst✝¹ : HasKernel (G.map f)
inst✝ : PreservesLimit (parallelPair f 0) G
⊢ IsIso (PreservesKernel.iso G f).hom
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u₁
inst✝¹⁰ : Category.{v₁, u₁} C
inst✝⁹ : HasZeroMorphisms C
D : Type u₂
inst✝⁸ : Category.{v₂, u₂} D
inst✝⁷ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁶ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝⁵ : HasKernel f
inst✝⁴ : HasKernel (G.map f)
inst✝³ : PreservesLimit (parallelPair f 0) G
X' Y' : C
g : X' ⟶ Y'
inst✝² : HasKernel g
inst✝¹ : HasKernel (G.map g)
inst✝ : PreservesLimit (parallelPair g 0) G
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map f ≫ G.map q = G.map p ≫ G.map g
[PROOFSTEP]
rw [← G.map_comp, hpq, G.map_comp]
[GOAL]
C : Type u₁
inst✝¹⁰ : Category.{v₁, u₁} C
inst✝⁹ : HasZeroMorphisms C
D : Type u₂
inst✝⁸ : Category.{v₂, u₂} D
inst✝⁷ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁶ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝⁵ : HasKernel f
inst✝⁴ : HasKernel (G.map f)
inst✝³ : PreservesLimit (parallelPair f 0) G
X' Y' : C
g : X' ⟶ Y'
inst✝² : HasKernel g
inst✝¹ : HasKernel (G.map g)
inst✝ : PreservesLimit (parallelPair g 0) G
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ kernel.map (G.map f) (G.map g) (G.map p) (G.map q) (_ : G.map f ≫ G.map q = G.map p ≫ G.map g) ≫
      (PreservesKernel.iso G g).inv =
    (PreservesKernel.iso G f).inv ≫ G.map (kernel.map f g p q hpq)
[PROOFSTEP]
rw [Iso.comp_inv_eq, Category.assoc, PreservesKernel.iso_hom, Iso.eq_inv_comp, PreservesKernel.iso_hom,
  kernelComparison_comp_kernel_map]
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : CokernelCofork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ G.map f ≫ G.map (Cofork.π c) = 0
[PROOFSTEP]
rw [← G.map_comp, c.condition, G.map_zero]
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : CokernelCofork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ IsColimit (G.mapCocone c) ≃ IsColimit (map c G)
[PROOFSTEP]
refine' (IsColimit.precomposeHomEquiv _ _).symm.trans (IsColimit.equivIsoColimit _)
[GOAL]
case refine'_1
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : CokernelCofork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ parallelPair (G.map f) 0 ≅ parallelPair f 0 ⋙ G
[PROOFSTEP]
refine' parallelPair.ext (Iso.refl _) (Iso.refl _) _ _
[GOAL]
case refine'_1.refine'_1
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : CokernelCofork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ (parallelPair (G.map f) 0).map WalkingParallelPairHom.left ≫
      (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.one)).hom =
    (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.zero)).hom ≫
      (parallelPair f 0 ⋙ G).map WalkingParallelPairHom.left
[PROOFSTEP]
simp
[GOAL]
case refine'_1.refine'_2
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : CokernelCofork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ (parallelPair (G.map f) 0).map WalkingParallelPairHom.right ≫
      (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.one)).hom =
    (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.zero)).hom ≫
      (parallelPair f 0 ⋙ G).map WalkingParallelPairHom.right
[PROOFSTEP]
simp
[GOAL]
case refine'_2
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : CokernelCofork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ (Cocones.precompose
          (parallelPair.ext (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.zero))
              (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.one))
              (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
              (_ : 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map 0)).hom).obj
      (G.mapCocone c) ≅
    map c G
[PROOFSTEP]
exact Cocones.ext (Iso.refl _) (by rintro (_ | _) <;> aesop_cat)
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : CokernelCofork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ ∀ (j : WalkingParallelPair),
    NatTrans.app
          ((Cocones.precompose
                  (parallelPair.ext (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.zero))
                      (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.one))
                      (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
                      (_ : 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map 0)).hom).obj
              (G.mapCocone c)).ι
          j ≫
        (Iso.refl
            ((Cocones.precompose
                    (parallelPair.ext (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.zero))
                        (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.one))
                        (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
                        (_ : 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map 0)).hom).obj
                (G.mapCocone c)).pt).hom =
      NatTrans.app (map c G).ι j
[PROOFSTEP]
rintro (_ | _)
[GOAL]
case zero
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : CokernelCofork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ NatTrans.app
        ((Cocones.precompose
                (parallelPair.ext (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.zero))
                    (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.one))
                    (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
                    (_ : 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map 0)).hom).obj
            (G.mapCocone c)).ι
        WalkingParallelPair.zero ≫
      (Iso.refl
          ((Cocones.precompose
                  (parallelPair.ext (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.zero))
                      (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.one))
                      (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
                      (_ : 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map 0)).hom).obj
              (G.mapCocone c)).pt).hom =
    NatTrans.app (map c G).ι WalkingParallelPair.zero
[PROOFSTEP]
aesop_cat
[GOAL]
case one
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : CokernelCofork f
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
⊢ NatTrans.app
        ((Cocones.precompose
                (parallelPair.ext (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.zero))
                    (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.one))
                    (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
                    (_ : 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map 0)).hom).obj
            (G.mapCocone c)).ι
        WalkingParallelPair.one ≫
      (Iso.refl
          ((Cocones.precompose
                  (parallelPair.ext (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.zero))
                      (Iso.refl ((parallelPair (G.map f) 0).obj WalkingParallelPair.one))
                      (_ : G.map f ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map f)
                      (_ : 0 ≫ 𝟙 (G.obj Y) = 𝟙 (G.obj X) ≫ G.map 0)).hom).obj
              (G.mapCocone c)).pt).hom =
    NatTrans.app (map c G).ι WalkingParallelPair.one
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
⊢ G.map f ≫ G.map h = 0
[PROOFSTEP]
simp only [← G.map_comp, w, Functor.map_zero]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : HasZeroMorphisms C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : HasZeroMorphisms D
G : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝ : PreservesColimit (parallelPair f 0) G
l : IsColimit (CokernelCofork.ofπ h w)
⊢ G.map f ≫ G.map h = 0
[PROOFSTEP]
simp only [← G.map_comp, w, Functor.map_zero]
[GOAL]
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : HasZeroMorphisms C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝¹ : HasCokernel f
inst✝ : PreservesColimit (parallelPair f 0) G
⊢ G.map f ≫ G.map (cokernel.π f) = 0 ≫ G.map (cokernel.π f)
[PROOFSTEP]
simp only [← G.map_comp, cokernel.condition, zero_comp, Functor.map_zero]
[GOAL]
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : HasZeroMorphisms C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝¹ : HasCokernel f
inst✝ : HasCokernel (G.map f)
i : IsIso (cokernelComparison f G)
⊢ PreservesColimit (parallelPair f 0) G
[PROOFSTEP]
apply preservesColimitOfPreservesColimitCocone (cokernelIsCokernel f)
[GOAL]
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : HasZeroMorphisms C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝¹ : HasCokernel f
inst✝ : HasCokernel (G.map f)
i : IsIso (cokernelComparison f G)
⊢ IsColimit (G.mapCocone (Cofork.ofπ (cokernel.π f) (_ : f ≫ cokernel.π f = 0 ≫ cokernel.π f)))
[PROOFSTEP]
apply (isColimitMapCoconeCoforkEquiv' G (cokernel.condition f)).symm _
[GOAL]
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : HasZeroMorphisms C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝¹ : HasCokernel f
inst✝ : HasCokernel (G.map f)
i : IsIso (cokernelComparison f G)
⊢ IsColimit (CokernelCofork.ofπ (G.map (cokernel.π f)) (_ : G.map f ≫ G.map (cokernel.π f) = 0))
[PROOFSTEP]
exact @IsColimit.ofPointIso _ _ _ _ _ _ _ (cokernelIsCokernel (G.map f)) i
[GOAL]
C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝² : HasCokernel f
inst✝¹ : HasCokernel (G.map f)
inst✝ : PreservesColimit (parallelPair f 0) G
⊢ (iso G f).inv = cokernelComparison f G
[PROOFSTEP]
rw [← cancel_epi (cokernel.π _)]
[GOAL]
C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝² : HasCokernel f
inst✝¹ : HasCokernel (G.map f)
inst✝ : PreservesColimit (parallelPair f 0) G
⊢ cokernel.π (G.map f) ≫ (iso G f).inv = cokernel.π (G.map f) ≫ cokernelComparison f G
[PROOFSTEP]
simp [PreservesCokernel.iso]
[GOAL]
C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝² : HasCokernel f
inst✝¹ : HasCokernel (G.map f)
inst✝ : PreservesColimit (parallelPair f 0) G
⊢ IsIso (cokernelComparison f G)
[PROOFSTEP]
rw [← PreservesCokernel.iso_inv]
[GOAL]
C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝² : HasCokernel f
inst✝¹ : HasCokernel (G.map f)
inst✝ : PreservesColimit (parallelPair f 0) G
⊢ IsIso (PreservesCokernel.iso G f).inv
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u₁
inst✝¹⁰ : Category.{v₁, u₁} C
inst✝⁹ : HasZeroMorphisms C
D : Type u₂
inst✝⁸ : Category.{v₂, u₂} D
inst✝⁷ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁶ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝⁵ : HasCokernel f
inst✝⁴ : HasCokernel (G.map f)
inst✝³ : PreservesColimit (parallelPair f 0) G
X' Y' : C
g : X' ⟶ Y'
inst✝² : HasCokernel g
inst✝¹ : HasCokernel (G.map g)
inst✝ : PreservesColimit (parallelPair g 0) G
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map f ≫ G.map q = G.map p ≫ G.map g
[PROOFSTEP]
rw [← G.map_comp, hpq, G.map_comp]
[GOAL]
C : Type u₁
inst✝¹⁰ : Category.{v₁, u₁} C
inst✝⁹ : HasZeroMorphisms C
D : Type u₂
inst✝⁸ : Category.{v₂, u₂} D
inst✝⁷ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁶ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝⁵ : HasCokernel f
inst✝⁴ : HasCokernel (G.map f)
inst✝³ : PreservesColimit (parallelPair f 0) G
X' Y' : C
g : X' ⟶ Y'
inst✝² : HasCokernel g
inst✝¹ : HasCokernel (G.map g)
inst✝ : PreservesColimit (parallelPair g 0) G
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ (PreservesCokernel.iso G f).hom ≫
      cokernel.map (G.map f) (G.map g) (G.map p) (G.map q) (_ : G.map f ≫ G.map q = G.map p ≫ G.map g) =
    G.map (cokernel.map f g p q hpq) ≫ (PreservesCokernel.iso G g).hom
[PROOFSTEP]
rw [← Iso.comp_inv_eq, Category.assoc, ← Iso.eq_inv_comp, PreservesCokernel.iso_inv,
  cokernel_map_comp_cokernelComparison, PreservesCokernel.iso_inv]
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
c : Cone (parallelPair 0 0)
hc : IsLimit c
⊢ IsLimit (G.mapCone c)
[PROOFSTEP]
have := KernelFork.IsLimit.isIso_ι c hc rfl
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
c : Cone (parallelPair 0 0)
hc : IsLimit c
this : IsIso (Fork.ι c)
⊢ IsLimit (G.mapCone c)
[PROOFSTEP]
refine' (KernelFork.isLimitMapConeEquiv c G).symm _
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
c : Cone (parallelPair 0 0)
hc : IsLimit c
this : IsIso (Fork.ι c)
⊢ IsLimit (KernelFork.map c G)
[PROOFSTEP]
refine' IsLimit.ofIsoLimit (KernelFork.IsLimit.ofId _ (G.map_zero _ _)) _
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
c : Cone (parallelPair 0 0)
hc : IsLimit c
this : IsIso (Fork.ι c)
⊢ KernelFork.ofι (𝟙 (G.obj X)) (_ : 𝟙 (G.obj X) ≫ G.map 0 = 0) ≅ KernelFork.map c G
[PROOFSTEP]
exact (Fork.ext (G.mapIso (asIso (Fork.ι c))).symm (by simp))
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
c : Cone (parallelPair 0 0)
hc : IsLimit c
this : IsIso (Fork.ι c)
⊢ (G.mapIso (asIso (Fork.ι c))).symm.hom ≫ Fork.ι (KernelFork.map c G) =
    Fork.ι (KernelFork.ofι (𝟙 (G.obj X)) (_ : 𝟙 (G.obj X) ≫ G.map 0 = 0))
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
c : Cocone (parallelPair 0 0)
hc : IsColimit c
⊢ IsColimit (G.mapCocone c)
[PROOFSTEP]
have := CokernelCofork.IsColimit.isIso_π c hc rfl
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
c : Cocone (parallelPair 0 0)
hc : IsColimit c
this : IsIso (Cofork.π c)
⊢ IsColimit (G.mapCocone c)
[PROOFSTEP]
refine' (CokernelCofork.isColimitMapCoconeEquiv c G).symm _
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
c : Cocone (parallelPair 0 0)
hc : IsColimit c
this : IsIso (Cofork.π c)
⊢ IsColimit (CokernelCofork.map c G)
[PROOFSTEP]
refine' IsColimit.ofIsoColimit (CokernelCofork.IsColimit.ofId _ (G.map_zero _ _)) _
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
c : Cocone (parallelPair 0 0)
hc : IsColimit c
this : IsIso (Cofork.π c)
⊢ CokernelCofork.ofπ (𝟙 (G.obj Y)) (_ : G.map 0 ≫ 𝟙 (G.obj Y) = 0) ≅ CokernelCofork.map c G
[PROOFSTEP]
exact (Cofork.ext (G.mapIso (asIso (Cofork.π c))) (by simp))
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
c : Cocone (parallelPair 0 0)
hc : IsColimit c
this : IsIso (Cofork.π c)
⊢ Cofork.π (CokernelCofork.ofπ (𝟙 (G.obj Y)) (_ : G.map 0 ≫ 𝟙 (G.obj Y) = 0)) ≫ (G.mapIso (asIso (Cofork.π c))).hom =
    Cofork.π (CokernelCofork.map c G)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
f : X ⟶ Y
hf : f = 0
⊢ PreservesLimit (parallelPair f 0) G
[PROOFSTEP]
rw [hf]
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
f : X ⟶ Y
hf : f = 0
⊢ PreservesLimit (parallelPair 0 0) G
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
f : X ⟶ Y
hf : f = 0
⊢ PreservesColimit (parallelPair f 0) G
[PROOFSTEP]
rw [hf]
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
G : C ⥤ D
inst✝ : Functor.PreservesZeroMorphisms G
f : X ⟶ Y
hf : f = 0
⊢ PreservesColimit (parallelPair 0 0) G
[PROOFSTEP]
infer_instance


[GOAL]
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.1655, u_3} D₁
inst✝⁴ : Category.{?u.1659, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
⊢ 𝟭 D₁ ⟶ G' ⋙ F'
[PROOFSTEP]
letI : Lifting L₁ W₁ ((G ⋙ F) ⋙ L₁) (G' ⋙ F') := Lifting.mk (CatCommSq.hComp G F L₁ L₂ L₁ G' F').iso'.symm
[GOAL]
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.1655, u_3} D₁
inst✝⁴ : Category.{?u.1659, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
this : Lifting L₁ W₁ ((G ⋙ F) ⋙ L₁) (G' ⋙ F') := { iso' := CatCommSq.iso'.symm }
⊢ 𝟭 D₁ ⟶ G' ⋙ F'
[PROOFSTEP]
exact Localization.liftNatTrans L₁ W₁ L₁ ((G ⋙ F) ⋙ L₁) (𝟭 D₁) (G' ⋙ F') (whiskerRight adj.unit L₁)
[GOAL]
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{u_5, u_3} D₁
inst✝⁴ : Category.{u_6, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₁ : C₁
⊢ NatTrans.app (ε adj L₁ W₁ L₂ G' F') (L₁.obj X₁) =
    L₁.map (NatTrans.app adj.unit X₁) ≫
      NatTrans.app (CatCommSq.iso F L₂ L₁ F').hom (G.obj X₁) ≫ F'.map (NatTrans.app (CatCommSq.iso G L₁ L₂ G').hom X₁)
[PROOFSTEP]
letI : Lifting L₁ W₁ ((G ⋙ F) ⋙ L₁) (G' ⋙ F') := Lifting.mk (CatCommSq.hComp G F L₁ L₂ L₁ G' F').iso'.symm
[GOAL]
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{u_5, u_3} D₁
inst✝⁴ : Category.{u_6, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₁ : C₁
this : Lifting L₁ W₁ ((G ⋙ F) ⋙ L₁) (G' ⋙ F') := { iso' := CatCommSq.iso'.symm }
⊢ NatTrans.app (ε adj L₁ W₁ L₂ G' F') (L₁.obj X₁) =
    L₁.map (NatTrans.app adj.unit X₁) ≫
      NatTrans.app (CatCommSq.iso F L₂ L₁ F').hom (G.obj X₁) ≫ F'.map (NatTrans.app (CatCommSq.iso G L₁ L₂ G').hom X₁)
[PROOFSTEP]
simp only [ε, liftNatTrans_app, Lifting.iso, Iso.symm, Functor.id_obj, Functor.comp_obj, Lifting.id_iso',
  Functor.rightUnitor_hom_app, whiskerRight_app, CatCommSq.hComp_iso'_hom_app, id_comp]
[GOAL]
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.13571, u_3} D₁
inst✝⁴ : Category.{?u.13575, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
⊢ F' ⋙ G' ⟶ 𝟭 D₂
[PROOFSTEP]
letI : Lifting L₂ W₂ ((F ⋙ G) ⋙ L₂) (F' ⋙ G') := Lifting.mk (CatCommSq.hComp F G L₂ L₁ L₂ F' G').iso'.symm
[GOAL]
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.13571, u_3} D₁
inst✝⁴ : Category.{?u.13575, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
this : Lifting L₂ W₂ ((F ⋙ G) ⋙ L₂) (F' ⋙ G') := { iso' := CatCommSq.iso'.symm }
⊢ F' ⋙ G' ⟶ 𝟭 D₂
[PROOFSTEP]
exact liftNatTrans L₂ W₂ ((F ⋙ G) ⋙ L₂) L₂ (F' ⋙ G') (𝟭 D₂) (whiskerRight adj.counit L₂)
[GOAL]
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{u_6, u_3} D₁
inst✝⁴ : Category.{u_5, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₂ : C₂
⊢ NatTrans.app (η adj L₁ L₂ W₂ G' F') (L₂.obj X₂) =
    G'.map (NatTrans.app (CatCommSq.iso F L₂ L₁ F').inv X₂) ≫
      NatTrans.app (CatCommSq.iso G L₁ L₂ G').inv (F.obj X₂) ≫ L₂.map (NatTrans.app adj.counit X₂)
[PROOFSTEP]
letI : Lifting L₂ W₂ ((F ⋙ G) ⋙ L₂) (F' ⋙ G') := Lifting.mk (CatCommSq.hComp F G L₂ L₁ L₂ F' G').iso'.symm
[GOAL]
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{u_6, u_3} D₁
inst✝⁴ : Category.{u_5, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₂ : C₂
this : Lifting L₂ W₂ ((F ⋙ G) ⋙ L₂) (F' ⋙ G') := { iso' := CatCommSq.iso'.symm }
⊢ NatTrans.app (η adj L₁ L₂ W₂ G' F') (L₂.obj X₂) =
    G'.map (NatTrans.app (CatCommSq.iso F L₂ L₁ F').inv X₂) ≫
      NatTrans.app (CatCommSq.iso G L₁ L₂ G').inv (F.obj X₂) ≫ L₂.map (NatTrans.app adj.counit X₂)
[PROOFSTEP]
simp only [η, liftNatTrans_app, Lifting.iso, Iso.symm, CatCommSq.hComp_iso'_inv_app, whiskerRight_app, Lifting.id_iso',
  Functor.rightUnitor_inv_app, comp_id, assoc]
[GOAL]
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
⊢ whiskerRight (Localization.ε adj L₁ W₁ L₂ G' F') G' ≫
      (Functor.associator G' F' G').hom ≫ whiskerLeft G' (Localization.η adj L₁ L₂ W₂ G' F') =
    NatTrans.id (𝟭 D₁ ⋙ G')
[PROOFSTEP]
apply natTrans_ext L₁ W₁
[GOAL]
case h
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
⊢ ∀ (X : C₁),
    NatTrans.app
        (whiskerRight (Localization.ε adj L₁ W₁ L₂ G' F') G' ≫
          (Functor.associator G' F' G').hom ≫ whiskerLeft G' (Localization.η adj L₁ L₂ W₂ G' F'))
        (L₁.obj X) =
      NatTrans.app (NatTrans.id (𝟭 D₁ ⋙ G')) (L₁.obj X)
[PROOFSTEP]
intro X₁
[GOAL]
case h
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₁ : C₁
⊢ NatTrans.app
      (whiskerRight (Localization.ε adj L₁ W₁ L₂ G' F') G' ≫
        (Functor.associator G' F' G').hom ≫ whiskerLeft G' (Localization.η adj L₁ L₂ W₂ G' F'))
      (L₁.obj X₁) =
    NatTrans.app (NatTrans.id (𝟭 D₁ ⋙ G')) (L₁.obj X₁)
[PROOFSTEP]
have eq := congr_app adj.left_triangle X₁
[GOAL]
case h
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₁ : C₁
eq : NatTrans.app (whiskerRight adj.unit G ≫ whiskerLeft G adj.counit) X₁ = NatTrans.app (𝟙 (𝟭 C₁ ⋙ G)) X₁
⊢ NatTrans.app
      (whiskerRight (Localization.ε adj L₁ W₁ L₂ G' F') G' ≫
        (Functor.associator G' F' G').hom ≫ whiskerLeft G' (Localization.η adj L₁ L₂ W₂ G' F'))
      (L₁.obj X₁) =
    NatTrans.app (NatTrans.id (𝟭 D₁ ⋙ G')) (L₁.obj X₁)
[PROOFSTEP]
dsimp at eq
[GOAL]
case h
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₁ : C₁
eq : G.map (NatTrans.app adj.unit X₁) ≫ NatTrans.app adj.counit (G.obj X₁) = 𝟙 (G.obj X₁)
⊢ NatTrans.app
      (whiskerRight (Localization.ε adj L₁ W₁ L₂ G' F') G' ≫
        (Functor.associator G' F' G').hom ≫ whiskerLeft G' (Localization.η adj L₁ L₂ W₂ G' F'))
      (L₁.obj X₁) =
    NatTrans.app (NatTrans.id (𝟭 D₁ ⋙ G')) (L₁.obj X₁)
[PROOFSTEP]
rw [NatTrans.comp_app, NatTrans.comp_app, whiskerRight_app, Localization.ε_app, Functor.associator_hom_app, id_comp,
  whiskerLeft_app, G'.map_comp, G'.map_comp, assoc, assoc]
[GOAL]
case h
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₁ : C₁
eq : G.map (NatTrans.app adj.unit X₁) ≫ NatTrans.app adj.counit (G.obj X₁) = 𝟙 (G.obj X₁)
⊢ G'.map (L₁.map (NatTrans.app adj.unit X₁)) ≫
      G'.map (NatTrans.app (CatCommSq.iso F L₂ L₁ F').hom (G.obj X₁)) ≫
        G'.map (F'.map (NatTrans.app (CatCommSq.iso G L₁ L₂ G').hom X₁)) ≫
          NatTrans.app (Localization.η adj L₁ L₂ W₂ G' F') (G'.obj (L₁.obj X₁)) =
    NatTrans.app (NatTrans.id (𝟭 D₁ ⋙ G')) (L₁.obj X₁)
[PROOFSTEP]
erw [(Localization.η adj L₁ L₂ W₂ G' F').naturality, Localization.η_app, assoc, assoc, ← G'.map_comp_assoc, ←
  G'.map_comp_assoc, assoc, Iso.hom_inv_id_app, comp_id, (CatCommSq.iso G L₁ L₂ G').inv.naturality_assoc, ←
  L₂.map_comp_assoc, eq, L₂.map_id, id_comp, Iso.inv_hom_id_app]
[GOAL]
case h
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₁ : C₁
eq : G.map (NatTrans.app adj.unit X₁) ≫ NatTrans.app adj.counit (G.obj X₁) = 𝟙 (G.obj X₁)
⊢ 𝟙 ((L₁ ⋙ G').obj ((𝟭 C₁).obj X₁)) = NatTrans.app (NatTrans.id (𝟭 D₁ ⋙ G')) (L₁.obj X₁)
[PROOFSTEP]
rfl
[GOAL]
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
⊢ whiskerLeft F' (Localization.ε adj L₁ W₁ L₂ G' F') ≫
      (Functor.associator F' G' F').inv ≫ whiskerRight (Localization.η adj L₁ L₂ W₂ G' F') F' =
    NatTrans.id (F' ⋙ 𝟭 D₁)
[PROOFSTEP]
apply natTrans_ext L₂ W₂
[GOAL]
case h
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
⊢ ∀ (X : C₂),
    NatTrans.app
        (whiskerLeft F' (Localization.ε adj L₁ W₁ L₂ G' F') ≫
          (Functor.associator F' G' F').inv ≫ whiskerRight (Localization.η adj L₁ L₂ W₂ G' F') F')
        (L₂.obj X) =
      NatTrans.app (NatTrans.id (F' ⋙ 𝟭 D₁)) (L₂.obj X)
[PROOFSTEP]
intro X₂
[GOAL]
case h
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₂ : C₂
⊢ NatTrans.app
      (whiskerLeft F' (Localization.ε adj L₁ W₁ L₂ G' F') ≫
        (Functor.associator F' G' F').inv ≫ whiskerRight (Localization.η adj L₁ L₂ W₂ G' F') F')
      (L₂.obj X₂) =
    NatTrans.app (NatTrans.id (F' ⋙ 𝟭 D₁)) (L₂.obj X₂)
[PROOFSTEP]
have eq := congr_app adj.right_triangle X₂
[GOAL]
case h
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₂ : C₂
eq : NatTrans.app (whiskerLeft F adj.unit ≫ whiskerRight adj.counit F) X₂ = NatTrans.app (𝟙 (F ⋙ 𝟭 C₁)) X₂
⊢ NatTrans.app
      (whiskerLeft F' (Localization.ε adj L₁ W₁ L₂ G' F') ≫
        (Functor.associator F' G' F').inv ≫ whiskerRight (Localization.η adj L₁ L₂ W₂ G' F') F')
      (L₂.obj X₂) =
    NatTrans.app (NatTrans.id (F' ⋙ 𝟭 D₁)) (L₂.obj X₂)
[PROOFSTEP]
dsimp at eq
[GOAL]
case h
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₂ : C₂
eq : NatTrans.app adj.unit (F.obj X₂) ≫ F.map (NatTrans.app adj.counit X₂) = 𝟙 (F.obj X₂)
⊢ NatTrans.app
      (whiskerLeft F' (Localization.ε adj L₁ W₁ L₂ G' F') ≫
        (Functor.associator F' G' F').inv ≫ whiskerRight (Localization.η adj L₁ L₂ W₂ G' F') F')
      (L₂.obj X₂) =
    NatTrans.app (NatTrans.id (F' ⋙ 𝟭 D₁)) (L₂.obj X₂)
[PROOFSTEP]
rw [NatTrans.comp_app, NatTrans.comp_app, whiskerLeft_app, whiskerRight_app, Localization.η_app,
  Functor.associator_inv_app, id_comp, F'.map_comp, F'.map_comp]
[GOAL]
case h
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₂ : C₂
eq : NatTrans.app adj.unit (F.obj X₂) ≫ F.map (NatTrans.app adj.counit X₂) = 𝟙 (F.obj X₂)
⊢ NatTrans.app (Localization.ε adj L₁ W₁ L₂ G' F') (F'.obj (L₂.obj X₂)) ≫
      F'.map (G'.map (NatTrans.app (CatCommSq.iso F L₂ L₁ F').inv X₂)) ≫
        F'.map (NatTrans.app (CatCommSq.iso G L₁ L₂ G').inv (F.obj X₂)) ≫ F'.map (L₂.map (NatTrans.app adj.counit X₂)) =
    NatTrans.app (NatTrans.id (F' ⋙ 𝟭 D₁)) (L₂.obj X₂)
[PROOFSTEP]
erw [← (Localization.ε _ _ _ _ _ _).naturality_assoc, Localization.ε_app, assoc, assoc, ← F'.map_comp_assoc,
  Iso.hom_inv_id_app, F'.map_id, id_comp, ← NatTrans.naturality, ← L₁.map_comp_assoc, eq, L₁.map_id, id_comp,
  Iso.inv_hom_id_app]
[GOAL]
case h
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{?u.24676, u_3} D₁
inst✝⁴ : Category.{?u.24680, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₂ : C₂
eq : NatTrans.app adj.unit (F.obj X₂) ≫ F.map (NatTrans.app adj.counit X₂) = 𝟙 (F.obj X₂)
⊢ 𝟙 ((L₂ ⋙ F').obj X₂) = NatTrans.app (NatTrans.id (F' ⋙ 𝟭 D₁)) (L₂.obj X₂)
[PROOFSTEP]
rfl
[GOAL]
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{u_5, u_3} D₁
inst✝⁴ : Category.{u_6, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₁ : C₁
⊢ NatTrans.app (localization adj L₁ W₁ L₂ W₂ G' F').unit (L₁.obj X₁) =
    L₁.map (NatTrans.app adj.unit X₁) ≫
      NatTrans.app (CatCommSq.iso F L₂ L₁ F').hom (G.obj X₁) ≫ F'.map (NatTrans.app (CatCommSq.iso G L₁ L₂ G').hom X₁)
[PROOFSTEP]
apply Localization.ε_app
[GOAL]
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_1, u_1} C₁
inst✝⁶ : Category.{u_2, u_2} C₂
inst✝⁵ : Category.{u_6, u_3} D₁
inst✝⁴ : Category.{u_5, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : Functor.IsLocalization L₁ W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : Functor.IsLocalization L₂ W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₂ : C₂
⊢ NatTrans.app (localization adj L₁ W₁ L₂ W₂ G' F').counit (L₂.obj X₂) =
    G'.map (NatTrans.app (CatCommSq.iso F L₂ L₁ F').inv X₂) ≫
      NatTrans.app (CatCommSq.iso G L₁ L₂ G').inv (F.obj X₂) ≫ L₂.map (NatTrans.app adj.counit X₂)
[PROOFSTEP]
apply Localization.η_app