[GOAL]
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
δ : α → Type u_2
t : (a : α) → Finset (δ a)
x✝¹ x✝ : (a : α) → a ∈ univ → δ a
⊢ (fun f a => f a (_ : a ∈ univ)) x✝¹ = (fun f a => f a (_ : a ∈ univ)) x✝ → x✝¹ = x✝
[PROOFSTEP]
simp (config := { contextual := true }) [Function.funext_iff]
[GOAL]
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
δ : α → Type u_2
t : (a : α) → Finset (δ a)
f : (a : α) → δ a
⊢ f ∈ piFinset t ↔ ∀ (a : α), f a ∈ t a
[PROOFSTEP]
constructor
[GOAL]
case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
δ : α → Type u_2
t : (a : α) → Finset (δ a)
f : (a : α) → δ a
⊢ f ∈ piFinset t → ∀ (a : α), f a ∈ t a
[PROOFSTEP]
simp only [piFinset, mem_map, and_imp, forall_prop_of_true, exists_prop, mem_univ, exists_imp, mem_pi]
[GOAL]
case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
δ : α → Type u_2
t : (a : α) → Finset (δ a)
f : (a : α) → δ a
⊢ ∀ (x : (a : α) → a ∈ univ → δ a),
    (∀ (a : α), x a (_ : a ∈ univ) ∈ t a) →
      ↑{ toFun := fun f a => f a (_ : a ∈ univ),
                inj' :=
                  (_ :
                    ∀ (x x_1 : (a : α) → a ∈ univ → δ a),
                      ((fun a => x a (_ : a ∈ univ)) = fun a => x_1 a (_ : a ∈ univ)) → x = x_1) }
            x =
          f →
        ∀ (a : α), f a ∈ t a
[PROOFSTEP]
rintro g hg hgf a
[GOAL]
case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
δ : α → Type u_2
t : (a : α) → Finset (δ a)
f : (a : α) → δ a
g : (a : α) → a ∈ univ → δ a
hg : ∀ (a : α), g a (_ : a ∈ univ) ∈ t a
hgf :
  ↑{ toFun := fun f a => f a (_ : a ∈ univ),
          inj' :=
            (_ :
              ∀ (x x_1 : (a : α) → a ∈ univ → δ a),
                ((fun a => x a (_ : a ∈ univ)) = fun a => x_1 a (_ : a ∈ univ)) → x = x_1) }
      g =
    f
a : α
⊢ f a ∈ t a
[PROOFSTEP]
rw [← hgf]
[GOAL]
case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
δ : α → Type u_2
t : (a : α) → Finset (δ a)
f : (a : α) → δ a
g : (a : α) → a ∈ univ → δ a
hg : ∀ (a : α), g a (_ : a ∈ univ) ∈ t a
hgf :
  ↑{ toFun := fun f a => f a (_ : a ∈ univ),
          inj' :=
            (_ :
              ∀ (x x_1 : (a : α) → a ∈ univ → δ a),
                ((fun a => x a (_ : a ∈ univ)) = fun a => x_1 a (_ : a ∈ univ)) → x = x_1) }
      g =
    f
a : α
⊢ ↑{ toFun := fun f a => f a (_ : a ∈ univ),
          inj' :=
            (_ :
              ∀ (x x_1 : (a : α) → a ∈ univ → δ a),
                ((fun a => x a (_ : a ∈ univ)) = fun a => x_1 a (_ : a ∈ univ)) → x = x_1) }
      g a ∈
    t a
[PROOFSTEP]
exact hg a
[GOAL]
case mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
δ : α → Type u_2
t : (a : α) → Finset (δ a)
f : (a : α) → δ a
⊢ (∀ (a : α), f a ∈ t a) → f ∈ piFinset t
[PROOFSTEP]
simp only [piFinset, mem_map, forall_prop_of_true, exists_prop, mem_univ, mem_pi]
[GOAL]
case mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
δ : α → Type u_2
t : (a : α) → Finset (δ a)
f : (a : α) → δ a
⊢ (∀ (a : α), f a ∈ t a) →
    ∃ a,
      (∀ (a_1 : α), a a_1 (_ : a_1 ∈ univ) ∈ t a_1) ∧
        ↑{ toFun := fun f a => f a (_ : a ∈ univ),
                inj' :=
                  (_ :
                    ∀ (x x_1 : (a : α) → a ∈ univ → δ a),
                      ((fun a => x a (_ : a ∈ univ)) = fun a => x_1 a (_ : a ∈ univ)) → x = x_1) }
            a =
          f
[PROOFSTEP]
exact fun hf => ⟨fun a _ => f a, hf, rfl⟩
[GOAL]
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
δ : α → Type u_2
t : (a : α) → Finset (δ a)
x : (a : α) → δ a
⊢ x ∈ ↑(piFinset t) ↔ x ∈ Set.pi Set.univ fun a => ↑(t a)
[PROOFSTEP]
rw [Set.mem_univ_pi]
[GOAL]
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
δ : α → Type u_2
t : (a : α) → Finset (δ a)
x : (a : α) → δ a
⊢ x ∈ ↑(piFinset t) ↔ ∀ (i : α), x i ∈ ↑(t i)
[PROOFSTEP]
exact Fintype.mem_piFinset
[GOAL]
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
δ : α → Type u_2
inst✝ : Nonempty α
x✝ : (a : α) → δ a
⊢ ¬x✝ ∈ piFinset fun x => ∅
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
δ : α → Type u_2
f x✝ : (a : α) → δ a
⊢ (x✝ ∈ piFinset fun i => {f i}) ↔ x✝ ∈ {f}
[PROOFSTEP]
simp only [Function.funext_iff, Fintype.mem_piFinset, mem_singleton]
[GOAL]
α✝ : Type u_1
α : Type u_2
β : α → Type u_3
inst✝² : DecidableEq α
inst✝¹ : Fintype α
inst✝ : (a : α) → Fintype (β a)
⊢ ∀ (x : (a : α) → β a), x ∈ Fintype.piFinset fun x => univ
[PROOFSTEP]
simp
[GOAL]
α✝ : Type u_1
α : Type ?u.21193
β : Type ?u.21196
inst✝¹ : Fintype α
inst✝ : Fintype β
⊢ Fintype (α ↪ β)
[PROOFSTEP]
classical. exact Fintype.ofEquiv _ (Equiv.subtypeInjectiveEquivEmbedding α β)
[GOAL]
α✝ : Type u_1
α : Type ?u.21193
β : Type ?u.21196
inst✝¹ : Fintype α
inst✝ : Fintype β
⊢ Fintype (α ↪ β)
[PROOFSTEP]
exact Fintype.ofEquiv _ (Equiv.subtypeInjectiveEquivEmbedding α β)
[GOAL]
α✝ : Type u_1
α : Type u_2
β : α → Type u_3
inst✝² : DecidableEq α
inst✝¹ : Fintype α
inst✝ : (a : α) → Fintype (β a)
⊢ (pi univ fun a => univ) = univ
[PROOFSTEP]
ext
[GOAL]
case a
α✝ : Type u_1
α : Type u_2
β : α → Type u_3
inst✝² : DecidableEq α
inst✝¹ : Fintype α
inst✝ : (a : α) → Fintype (β a)
a✝ : (a : α) → a ∈ univ → β a
⊢ (a✝ ∈ pi univ fun a => univ) ↔ a✝ ∈ univ
[PROOFSTEP]
simp


[GOAL]
C : Type (u + 1)
inst✝⁵ : Category.{u_1, u + 1} C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category.{u_2, u + 1} D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
⊢ IsIso f
[PROOFSTEP]
skip
[GOAL]
C : Type (u + 1)
inst✝⁵ : Category.{u_1, u + 1} C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category.{u_2, u + 1} D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
⊢ IsIso f
[PROOFSTEP]
haveI i' : IsIso ((forget D).map ((forget₂ C D).map f)) := Functor.map_isIso (forget D) _
[GOAL]
C : Type (u + 1)
inst✝⁵ : Category.{u_1, u + 1} C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category.{u_2, u + 1} D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
i' : IsIso ((forget D).map ((forget₂ C D).map f))
⊢ IsIso f
[PROOFSTEP]
haveI : IsIso ((forget C).map f) := by
  have := @HasForget₂.forget_comp C D
  rw [← this]
  exact i'
[GOAL]
C : Type (u + 1)
inst✝⁵ : Category.{u_1, u + 1} C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category.{u_2, u + 1} D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
i' : IsIso ((forget D).map ((forget₂ C D).map f))
⊢ IsIso ((forget C).map f)
[PROOFSTEP]
have := @HasForget₂.forget_comp C D
[GOAL]
C : Type (u + 1)
inst✝⁵ : Category.{u_1, u + 1} C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category.{u_2, u + 1} D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
i' : IsIso ((forget D).map ((forget₂ C D).map f))
this :
  ∀ [inst : Category.{?u.1872, u + 1} C] [inst_1 : ConcreteCategory C] [inst_2 : Category.{?u.1871, u + 1} D]
    [inst_3 : ConcreteCategory D] [self : HasForget₂ C D], HasForget₂.forget₂ ⋙ forget D = forget C
⊢ IsIso ((forget C).map f)
[PROOFSTEP]
rw [← this]
[GOAL]
C : Type (u + 1)
inst✝⁵ : Category.{u_1, u + 1} C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category.{u_2, u + 1} D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
i' : IsIso ((forget D).map ((forget₂ C D).map f))
this :
  ∀ [inst : Category.{u_1, u + 1} C] [inst_1 : ConcreteCategory C] [inst_2 : Category.{u_2, u + 1} D]
    [inst_3 : ConcreteCategory D] [self : HasForget₂ C D], HasForget₂.forget₂ ⋙ forget D = forget C
⊢ IsIso ((HasForget₂.forget₂ ⋙ forget D).map f)
[PROOFSTEP]
exact i'
[GOAL]
C : Type (u + 1)
inst✝⁵ : Category.{u_1, u + 1} C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category.{u_2, u + 1} D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
i' : IsIso ((forget D).map ((forget₂ C D).map f))
this : IsIso ((forget C).map f)
⊢ IsIso f
[PROOFSTEP]
apply isIso_of_reflects_iso f (forget C)


[GOAL]
⊢ 1 = 1
[PROOFSTEP]
sleep_heartbeats 1000
[GOAL]
⊢ 1 = 1
[PROOFSTEP]
rfl


[GOAL]
C : Type u_1
inst✝ : Category.{?u.4128, u_1} C
X Y : PresheafedSpace C
α β : Hom X Y
w : α.base = β.base
⊢ (Opens.map α.base).op = (Opens.map β.base).op
[PROOFSTEP]
rw [w]
[GOAL]
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
α β : Hom X Y
w : α.base = β.base
h : α.c ≫ whiskerRight (eqToHom (_ : (Opens.map α.base).op = (Opens.map β.base).op)) X.presheaf = β.c
⊢ α = β
[PROOFSTEP]
rcases α with ⟨base, c⟩
[GOAL]
case mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
β : Hom X Y
base : ↑X ⟶ ↑Y
c : Y.presheaf ⟶ base _* X.presheaf
w : { base := base, c := c }.base = β.base
h :
  { base := base, c := c }.c ≫
      whiskerRight (eqToHom (_ : (Opens.map { base := base, c := c }.base).op = (Opens.map β.base).op)) X.presheaf =
    β.c
⊢ { base := base, c := c } = β
[PROOFSTEP]
rcases β with ⟨base', c'⟩
[GOAL]
case mk.mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
base : ↑X ⟶ ↑Y
c : Y.presheaf ⟶ base _* X.presheaf
base' : ↑X ⟶ ↑Y
c' : Y.presheaf ⟶ base' _* X.presheaf
w : { base := base, c := c }.base = { base := base', c := c' }.base
h :
  { base := base, c := c }.c ≫
      whiskerRight
        (eqToHom (_ : (Opens.map { base := base, c := c }.base).op = (Opens.map { base := base', c := c' }.base).op))
        X.presheaf =
    { base := base', c := c' }.c
⊢ { base := base, c := c } = { base := base', c := c' }
[PROOFSTEP]
dsimp at w
[GOAL]
case mk.mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
base : ↑X ⟶ ↑Y
c : Y.presheaf ⟶ base _* X.presheaf
base' : ↑X ⟶ ↑Y
c' : Y.presheaf ⟶ base' _* X.presheaf
w : base = base'
h :
  { base := base, c := c }.c ≫
      whiskerRight
        (eqToHom (_ : (Opens.map { base := base, c := c }.base).op = (Opens.map { base := base', c := c' }.base).op))
        X.presheaf =
    { base := base', c := c' }.c
⊢ { base := base, c := c } = { base := base', c := c' }
[PROOFSTEP]
subst w
[GOAL]
case mk.mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
base : ↑X ⟶ ↑Y
c c' : Y.presheaf ⟶ base _* X.presheaf
h :
  { base := base, c := c }.c ≫
      whiskerRight
        (eqToHom (_ : (Opens.map { base := base, c := c }.base).op = (Opens.map { base := base, c := c' }.base).op))
        X.presheaf =
    { base := base, c := c' }.c
⊢ { base := base, c := c } = { base := base, c := c' }
[PROOFSTEP]
dsimp at h
[GOAL]
case mk.mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
base : ↑X ⟶ ↑Y
c c' : Y.presheaf ⟶ base _* X.presheaf
h : c ≫ whiskerRight (𝟙 (Opens.map base).op) X.presheaf = c'
⊢ { base := base, c := c } = { base := base, c := c' }
[PROOFSTEP]
erw [whiskerRight_id', comp_id] at h
[GOAL]
case mk.mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
base : ↑X ⟶ ↑Y
c c' : Y.presheaf ⟶ base _* X.presheaf
h : c = c'
⊢ { base := base, c := c } = { base := base, c := c' }
[PROOFSTEP]
subst h
[GOAL]
case mk.mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
base : ↑X ⟶ ↑Y
c : Y.presheaf ⟶ base _* X.presheaf
⊢ { base := base, c := c } = { base := base, c := c }
[PROOFSTEP]
rfl
[GOAL]
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
α β : Hom X Y
w : α.base = β.base
h : HEq α.c β.c
⊢ α = β
[PROOFSTEP]
cases α
[GOAL]
case mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
β : Hom X Y
base✝ : ↑X ⟶ ↑Y
c✝ : Y.presheaf ⟶ base✝ _* X.presheaf
w : { base := base✝, c := c✝ }.base = β.base
h : HEq { base := base✝, c := c✝ }.c β.c
⊢ { base := base✝, c := c✝ } = β
[PROOFSTEP]
cases β
[GOAL]
case mk.mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
base✝¹ : ↑X ⟶ ↑Y
c✝¹ : Y.presheaf ⟶ base✝¹ _* X.presheaf
base✝ : ↑X ⟶ ↑Y
c✝ : Y.presheaf ⟶ base✝ _* X.presheaf
w : { base := base✝¹, c := c✝¹ }.base = { base := base✝, c := c✝ }.base
h : HEq { base := base✝¹, c := c✝¹ }.c { base := base✝, c := c✝ }.c
⊢ { base := base✝¹, c := c✝¹ } = { base := base✝, c := c✝ }
[PROOFSTEP]
congr
[GOAL]
C : Type u_1
inst✝ : Category.{?u.68893, u_1} C
X✝ Y✝ : PresheafedSpace C
x✝ : X✝ ⟶ Y✝
⊢ 𝟙 X✝ ≫ x✝ = x✝
[PROOFSTEP]
dsimp
[GOAL]
C : Type u_1
inst✝ : Category.{?u.68893, u_1} C
X✝ Y✝ : PresheafedSpace C
x✝ : X✝ ⟶ Y✝
⊢ { base := 𝟙 ↑X✝ ≫ x✝.base, c := x✝.c ≫ (Presheaf.pushforward C x✝.base).map (𝟙 X✝.presheaf) } = x✝
[PROOFSTEP]
ext
[GOAL]
case w.w
C : Type u_1
inst✝ : Category.{?u.68893, u_1} C
X✝ Y✝ : PresheafedSpace C
x✝¹ : X✝ ⟶ Y✝
x✝ : (forget TopCat).obj ↑X✝
⊢ ↑{ base := 𝟙 ↑X✝ ≫ x✝¹.base, c := x✝¹.c ≫ (Presheaf.pushforward C x✝¹.base).map (𝟙 X✝.presheaf) }.base x✝ =
    ↑x✝¹.base x✝
[PROOFSTEP]
dsimp
[GOAL]
case w.w
C : Type u_1
inst✝ : Category.{?u.68893, u_1} C
X✝ Y✝ : PresheafedSpace C
x✝¹ : X✝ ⟶ Y✝
x✝ : (forget TopCat).obj ↑X✝
⊢ ↑(𝟙 ↑X✝ ≫ x✝¹.base) x✝ = ↑x✝¹.base x✝
[PROOFSTEP]
simp
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.68893, u_1} C
X✝ Y✝ : PresheafedSpace C
x✝ : X✝ ⟶ Y✝
U✝ : Opens ↑↑Y✝
⊢ NatTrans.app
      ({ base := 𝟙 ↑X✝ ≫ x✝.base, c := x✝.c ≫ (Presheaf.pushforward C x✝.base).map (𝟙 X✝.presheaf) }.c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map
                    { base := 𝟙 ↑X✝ ≫ x✝.base,
                        c := x✝.c ≫ (Presheaf.pushforward C x✝.base).map (𝟙 X✝.presheaf) }.base).op =
                (Opens.map x✝.base).op))
          X✝.presheaf)
      (op U✝) =
    NatTrans.app x✝.c (op U✝)
[PROOFSTEP]
dsimp
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.68893, u_1} C
X✝ Y✝ : PresheafedSpace C
x✝ : X✝ ⟶ Y✝
U✝ : Opens ↑↑Y✝
⊢ NatTrans.app
      ((x✝.c ≫ (Presheaf.pushforward C x✝.base).map (𝟙 X✝.presheaf)) ≫
        whiskerRight (𝟙 (Opens.map (𝟙 ↑X✝ ≫ x✝.base)).op) X✝.presheaf)
      (op U✝) =
    NatTrans.app x✝.c (op U✝)
[PROOFSTEP]
simp only [map_id, whiskerRight_id', assoc]
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.68893, u_1} C
X✝ Y✝ : PresheafedSpace C
x✝ : X✝ ⟶ Y✝
U✝ : Opens ↑↑Y✝
⊢ NatTrans.app
      (x✝.c ≫ 𝟙 ((Presheaf.pushforward C x✝.base).obj X✝.presheaf) ≫ 𝟙 ((Opens.map (𝟙 ↑X✝ ≫ x✝.base)).op ⋙ X✝.presheaf))
      (op U✝) =
    NatTrans.app x✝.c (op U✝)
[PROOFSTEP]
erw [comp_id, comp_id]
[GOAL]
C : Type u_1
inst✝ : Category.{?u.77226, u_1} C
X Y : PresheafedSpace C
α β : X ⟶ Y
w : α.base = β.base
⊢ (Opens.map α.base).op = (Opens.map β.base).op
[PROOFSTEP]
rw [w]
[GOAL]
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
U : (Opens ↑↑X)ᵒᵖ
⊢ NatTrans.app (𝟙 X).c U = X.presheaf.map (𝟙 U)
[PROOFSTEP]
rw [id_c, map_id]
[GOAL]
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
U : (Opens ↑↑X)ᵒᵖ
⊢ NatTrans.app (𝟙 X.presheaf) U = 𝟙 (X.presheaf.obj U)
[PROOFSTEP]
rfl
[GOAL]
C : Type u_1
inst✝ : Category.{?u.143246, u_1} C
X Y : PresheafedSpace C
α β : X ⟶ Y
h : α = β
U : (Opens ↑↑Y)ᵒᵖ
⊢ (Opens.map β.base).op.obj U = (Opens.map α.base).op.obj U
[PROOFSTEP]
subst h
[GOAL]
C : Type u_1
inst✝ : Category.{?u.143246, u_1} C
X Y : PresheafedSpace C
α : X ⟶ Y
U : (Opens ↑↑Y)ᵒᵖ
⊢ (Opens.map α.base).op.obj U = (Opens.map α.base).op.obj U
[PROOFSTEP]
rfl
[GOAL]
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
α β : X ⟶ Y
h : α = β
U : (Opens ↑↑Y)ᵒᵖ
⊢ NatTrans.app α.c U =
    NatTrans.app β.c U ≫ X.presheaf.map (eqToHom (_ : (Opens.map β.base).op.obj U = (Opens.map α.base).op.obj U))
[PROOFSTEP]
subst h
[GOAL]
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : PresheafedSpace C
α : X ⟶ Y
U : (Opens ↑↑Y)ᵒᵖ
⊢ NatTrans.app α.c U =
    NatTrans.app α.c U ≫ X.presheaf.map (eqToHom (_ : (Opens.map α.base).op.obj U = (Opens.map α.base).op.obj U))
[PROOFSTEP]
simp
[GOAL]
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
⊢ { base := H.hom, c := α.inv } ≫ { base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom } = 𝟙 X
[PROOFSTEP]
ext
[GOAL]
case w.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
x✝ : (CategoryTheory.forget TopCat).obj ↑X
⊢ ↑({ base := H.hom, c := α.inv } ≫ { base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom }).base x✝ =
    ↑(𝟙 X).base x✝
case h.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
U✝ : Opens ↑↑X
⊢ NatTrans.app
      (({ base := H.hom, c := α.inv } ≫ { base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom }).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map
                    ({ base := H.hom, c := α.inv } ≫
                        { base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom }).base).op =
                (Opens.map (𝟙 X).base).op))
          X.presheaf)
      (op U✝) =
    NatTrans.app (𝟙 X).c (op U✝)
[PROOFSTEP]
simp only [comp_base, Iso.hom_inv_id, FunctorToTypes.map_id_apply, id_base]
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
U✝ : Opens ↑↑X
⊢ NatTrans.app
      (({ base := H.hom, c := α.inv } ≫ { base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom }).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map
                    ({ base := H.hom, c := α.inv } ≫
                        { base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom }).base).op =
                (Opens.map (𝟙 X).base).op))
          X.presheaf)
      (op U✝) =
    NatTrans.app (𝟙 X).c (op U✝)
[PROOFSTEP]
rw [NatTrans.comp_app]
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
U✝ : Opens ↑↑X
⊢ NatTrans.app ({ base := H.hom, c := α.inv } ≫ { base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom }).c (op U✝) ≫
      NatTrans.app
        (whiskerRight
          (eqToHom
            (_ :
              (Opens.map
                    ({ base := H.hom, c := α.inv } ≫
                        { base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom }).base).op =
                (Opens.map (𝟙 X).base).op))
          X.presheaf)
        (op U✝) =
    NatTrans.app (𝟙 X).c (op U✝)
[PROOFSTEP]
simp only [id_base, comp_obj, op_obj, comp_base, Presheaf.pushforwardObj_obj, Opens.map_comp_obj, comp_c_app, unop_op,
  Presheaf.toPushforwardOfIso_app, assoc, Iso.hom_inv_id_app, comp_id, whiskerRight_app, eqToHom_app, id_c_app, map_id,
  ← Functor.map_comp, eqToHom_trans, eqToHom_refl]
[GOAL]
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
⊢ { base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom } ≫ { base := H.hom, c := α.inv } = 𝟙 Y
[PROOFSTEP]
ext
[GOAL]
case w.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
x✝ : (CategoryTheory.forget TopCat).obj ↑Y
⊢ ↑({ base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom } ≫ { base := H.hom, c := α.inv }).base x✝ =
    ↑(𝟙 Y).base x✝
case h.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
U✝ : Opens ↑↑Y
⊢ NatTrans.app
      (({ base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom } ≫ { base := H.hom, c := α.inv }).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map
                    ({ base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom } ≫
                        { base := H.hom, c := α.inv }).base).op =
                (Opens.map (𝟙 Y).base).op))
          Y.presheaf)
      (op U✝) =
    NatTrans.app (𝟙 Y).c (op U✝)
[PROOFSTEP]
dsimp
[GOAL]
case w.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
x✝ : (CategoryTheory.forget TopCat).obj ↑Y
⊢ ↑(H.inv ≫ H.hom) x✝ = ↑(𝟙 ↑Y) x✝
case h.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
U✝ : Opens ↑↑Y
⊢ NatTrans.app
      (({ base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom } ≫ { base := H.hom, c := α.inv }).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map
                    ({ base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom } ≫
                        { base := H.hom, c := α.inv }).base).op =
                (Opens.map (𝟙 Y).base).op))
          Y.presheaf)
      (op U✝) =
    NatTrans.app (𝟙 Y).c (op U✝)
[PROOFSTEP]
rw [H.inv_hom_id]
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
U✝ : Opens ↑↑Y
⊢ NatTrans.app
      (({ base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom } ≫ { base := H.hom, c := α.inv }).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map
                    ({ base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom } ≫
                        { base := H.hom, c := α.inv }).base).op =
                (Opens.map (𝟙 Y).base).op))
          Y.presheaf)
      (op U✝) =
    NatTrans.app (𝟙 Y).c (op U✝)
[PROOFSTEP]
dsimp
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
U✝ : Opens ↑↑Y
⊢ NatTrans.app
      (({ base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom } ≫ { base := H.hom, c := α.inv }).c ≫
        whiskerRight (eqToHom (_ : (Opens.map (H.inv ≫ H.hom)).op = (Opens.map (𝟙 ↑Y)).op)) Y.presheaf)
      (op U✝) =
    NatTrans.app (𝟙 Y).c (op U✝)
[PROOFSTEP]
rw [NatTrans.comp_app]
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
U✝ : Opens ↑↑Y
⊢ NatTrans.app ({ base := H.inv, c := Presheaf.toPushforwardOfIso H α.hom } ≫ { base := H.hom, c := α.inv }).c (op U✝) ≫
      NatTrans.app (whiskerRight (eqToHom (_ : (Opens.map (H.inv ≫ H.hom)).op = (Opens.map (𝟙 ↑Y)).op)) Y.presheaf)
        (op U✝) =
    NatTrans.app (𝟙 Y).c (op U✝)
[PROOFSTEP]
simp only [Presheaf.pushforwardObj_obj, op_obj, Opens.map_comp_obj, comp_obj, comp_c_app, unop_op,
  Presheaf.toPushforwardOfIso_app, whiskerRight_app, eqToHom_app, assoc, id_c_app, map_id]
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
U✝ : Opens ↑↑Y
⊢ NatTrans.app α.inv (op U✝) ≫
      X.presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map H.hom).obj U✝) =
                op
                  {
                    carrier :=
                      ↑H.hom ⁻¹'
                        ↑(op
                              { carrier := ↑H.inv ⁻¹' ↑(op ((Opens.map H.hom).obj U✝)).unop,
                                is_open' := (_ : IsOpen (↑H.inv ⁻¹' ↑(op ((Opens.map H.hom).obj U✝)).unop)) }).unop,
                    is_open' :=
                      (_ :
                        IsOpen
                          (↑H.hom ⁻¹'
                            ↑(op
                                  { carrier := ↑H.inv ⁻¹' ↑(op ((Opens.map H.hom).obj U✝)).unop,
                                    is_open' :=
                                      (_ : IsOpen (↑H.inv ⁻¹' ↑(op ((Opens.map H.hom).obj U✝)).unop)) }).unop)) })) ≫
        NatTrans.app α.hom (op ((Opens.map H.inv).obj ((Opens.map H.hom).obj U✝))) ≫
          Y.presheaf.map
            (eqToHom (_ : (Opens.map (H.inv ≫ H.hom)).op.obj (op U✝) = (Opens.map (𝟙 ↑Y)).op.obj (op U✝))) =
    𝟙 (Y.presheaf.obj (op U✝))
[PROOFSTEP]
rw [← α.hom.naturality, Presheaf.pushforwardObj_map, eqToHom_map, eqToHom_map, eqToHom_map, eqToHom_trans_assoc,
  eqToHom_refl, id_comp]
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.204326, u_1} C
X Y : PresheafedSpace C
H : ↑X ≅ ↑Y
α : H.hom _* X.presheaf ≅ Y.presheaf
U✝ : Opens ↑↑Y
⊢ NatTrans.app α.inv (op U✝) ≫ NatTrans.app α.hom (op ((Opens.map (𝟙 ↑Y)).obj U✝)) = 𝟙 (Y.presheaf.obj (op U✝))
[PROOFSTEP]
apply Iso.inv_hom_id_app
[GOAL]
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
⊢ H.hom.c ≫ Presheaf.pushforwardToOfIso ((forget C).mapIso H).symm H.inv.c = 𝟙 Y.presheaf
[PROOFSTEP]
ext U
[GOAL]
case w
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
U : Opens ↑↑Y
⊢ NatTrans.app (H.hom.c ≫ Presheaf.pushforwardToOfIso ((forget C).mapIso H).symm H.inv.c) (op U) =
    NatTrans.app (𝟙 Y.presheaf) (op U)
[PROOFSTEP]
rw [NatTrans.comp_app]
[GOAL]
case w
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
U : Opens ↑↑Y
⊢ NatTrans.app H.hom.c (op U) ≫ NatTrans.app (Presheaf.pushforwardToOfIso ((forget C).mapIso H).symm H.inv.c) (op U) =
    NatTrans.app (𝟙 Y.presheaf) (op U)
[PROOFSTEP]
simpa using congr_arg (fun f => f ≫ eqToHom _) (congr_app H.inv_hom_id (op U))
[GOAL]
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
⊢ Presheaf.pushforwardToOfIso ((forget C).mapIso H).symm H.inv.c ≫ H.hom.c = 𝟙 (H.hom.base _* X.presheaf)
[PROOFSTEP]
ext U
[GOAL]
case w
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
U : Opens ↑↑Y
⊢ NatTrans.app (Presheaf.pushforwardToOfIso ((forget C).mapIso H).symm H.inv.c ≫ H.hom.c) (op U) =
    NatTrans.app (𝟙 (H.hom.base _* X.presheaf)) (op U)
[PROOFSTEP]
dsimp
[GOAL]
case w
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
U : Opens ↑↑Y
⊢ NatTrans.app (Presheaf.pushforwardToOfIso ((forget C).mapIso H).symm H.inv.c ≫ H.hom.c) (op U) =
    NatTrans.app (𝟙 (H.hom.base _* X.presheaf)) (op U)
[PROOFSTEP]
rw [NatTrans.comp_app, NatTrans.id_app]
[GOAL]
case w
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
U : Opens ↑↑Y
⊢ NatTrans.app (Presheaf.pushforwardToOfIso ((forget C).mapIso H).symm H.inv.c) (op U) ≫ NatTrans.app H.hom.c (op U) =
    𝟙 ((H.hom.base _* X.presheaf).obj (op U))
[PROOFSTEP]
simp only [Presheaf.pushforwardObj_obj, op_obj, Presheaf.pushforwardToOfIso_app, Iso.symm_inv, mapIso_hom, forget_map,
  Iso.symm_hom, mapIso_inv, unop_op, eqToHom_map, assoc]
[GOAL]
case w
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
U : Opens ↑↑Y
⊢ NatTrans.app H.inv.c (op ((Opens.map H.hom.base).obj U)) ≫
      eqToHom
          (_ :
            Y.presheaf.obj (op ((Opens.map H.inv.base).obj ((Opens.map H.hom.base).obj U))) = Y.presheaf.obj (op U)) ≫
        NatTrans.app H.hom.c (op U) =
    𝟙 (X.presheaf.obj (op ((Opens.map H.hom.base).obj U)))
[PROOFSTEP]
have eq₁ := congr_app H.hom_inv_id (op ((Opens.map H.hom.base).obj U))
[GOAL]
case w
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
U : Opens ↑↑Y
eq₁ :
  NatTrans.app (H.hom ≫ H.inv).c (op ((Opens.map H.hom.base).obj U)) =
    NatTrans.app (𝟙 X).c (op ((Opens.map H.hom.base).obj U)) ≫
      X.presheaf.map
        (eqToHom
          (_ :
            (Opens.map (𝟙 X).base).op.obj (op ((Opens.map H.hom.base).obj U)) =
              (Opens.map (H.hom ≫ H.inv).base).op.obj (op ((Opens.map H.hom.base).obj U))))
⊢ NatTrans.app H.inv.c (op ((Opens.map H.hom.base).obj U)) ≫
      eqToHom
          (_ :
            Y.presheaf.obj (op ((Opens.map H.inv.base).obj ((Opens.map H.hom.base).obj U))) = Y.presheaf.obj (op U)) ≫
        NatTrans.app H.hom.c (op U) =
    𝟙 (X.presheaf.obj (op ((Opens.map H.hom.base).obj U)))
[PROOFSTEP]
have eq₂ := H.hom.c.naturality (eqToHom (congr_obj (congr_arg Opens.map ((forget C).congr_map H.inv_hom_id.symm)) U)).op
[GOAL]
case w
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
U : Opens ↑↑Y
eq₁ :
  NatTrans.app (H.hom ≫ H.inv).c (op ((Opens.map H.hom.base).obj U)) =
    NatTrans.app (𝟙 X).c (op ((Opens.map H.hom.base).obj U)) ≫
      X.presheaf.map
        (eqToHom
          (_ :
            (Opens.map (𝟙 X).base).op.obj (op ((Opens.map H.hom.base).obj U)) =
              (Opens.map (H.hom ≫ H.inv).base).op.obj (op ((Opens.map H.hom.base).obj U))))
eq₂ :
  Y.presheaf.map
        (eqToHom
            (_ : (Opens.map ((forget C).map (𝟙 Y))).obj U = (Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U)).op ≫
      NatTrans.app H.hom.c (op ((Opens.map ((forget C).map (𝟙 Y))).obj U)) =
    NatTrans.app H.hom.c (op ((Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U)) ≫
      (H.hom.base _* X.presheaf).map
        (eqToHom (_ : (Opens.map ((forget C).map (𝟙 Y))).obj U = (Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U)).op
⊢ NatTrans.app H.inv.c (op ((Opens.map H.hom.base).obj U)) ≫
      eqToHom
          (_ :
            Y.presheaf.obj (op ((Opens.map H.inv.base).obj ((Opens.map H.hom.base).obj U))) = Y.presheaf.obj (op U)) ≫
        NatTrans.app H.hom.c (op U) =
    𝟙 (X.presheaf.obj (op ((Opens.map H.hom.base).obj U)))
[PROOFSTEP]
rw [id_c, NatTrans.id_app, id_comp, eqToHom_map, comp_c_app] at eq₁
[GOAL]
case w
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
U : Opens ↑↑Y
eq₁ :
  NatTrans.app H.inv.c (op ((Opens.map H.hom.base).obj U)) ≫
      NatTrans.app H.hom.c (op ((Opens.map H.inv.base).obj (op ((Opens.map H.hom.base).obj U)).unop)) =
    eqToHom
      (_ :
        X.presheaf.obj ((Opens.map (𝟙 X).base).op.obj (op ((Opens.map H.hom.base).obj U))) =
          X.presheaf.obj ((Opens.map (H.hom ≫ H.inv).base).op.obj (op ((Opens.map H.hom.base).obj U))))
eq₂ :
  Y.presheaf.map
        (eqToHom
            (_ : (Opens.map ((forget C).map (𝟙 Y))).obj U = (Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U)).op ≫
      NatTrans.app H.hom.c (op ((Opens.map ((forget C).map (𝟙 Y))).obj U)) =
    NatTrans.app H.hom.c (op ((Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U)) ≫
      (H.hom.base _* X.presheaf).map
        (eqToHom (_ : (Opens.map ((forget C).map (𝟙 Y))).obj U = (Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U)).op
⊢ NatTrans.app H.inv.c (op ((Opens.map H.hom.base).obj U)) ≫
      eqToHom
          (_ :
            Y.presheaf.obj (op ((Opens.map H.inv.base).obj ((Opens.map H.hom.base).obj U))) = Y.presheaf.obj (op U)) ≫
        NatTrans.app H.hom.c (op U) =
    𝟙 (X.presheaf.obj (op ((Opens.map H.hom.base).obj U)))
[PROOFSTEP]
rw [eqToHom_op, eqToHom_map] at eq₂
[GOAL]
case w
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
U : Opens ↑↑Y
eq₁ :
  NatTrans.app H.inv.c (op ((Opens.map H.hom.base).obj U)) ≫
      NatTrans.app H.hom.c (op ((Opens.map H.inv.base).obj (op ((Opens.map H.hom.base).obj U)).unop)) =
    eqToHom
      (_ :
        X.presheaf.obj ((Opens.map (𝟙 X).base).op.obj (op ((Opens.map H.hom.base).obj U))) =
          X.presheaf.obj ((Opens.map (H.hom ≫ H.inv).base).op.obj (op ((Opens.map H.hom.base).obj U))))
eq₂ :
  eqToHom
        (_ :
          Y.presheaf.obj (op ((Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U)) =
            Y.presheaf.obj (op ((Opens.map ((forget C).map (𝟙 Y))).obj U))) ≫
      NatTrans.app H.hom.c (op ((Opens.map ((forget C).map (𝟙 Y))).obj U)) =
    NatTrans.app H.hom.c (op ((Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U)) ≫
      (H.hom.base _* X.presheaf).map
        (eqToHom
          (_ : op ((Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U) = op ((Opens.map ((forget C).map (𝟙 Y))).obj U)))
⊢ NatTrans.app H.inv.c (op ((Opens.map H.hom.base).obj U)) ≫
      eqToHom
          (_ :
            Y.presheaf.obj (op ((Opens.map H.inv.base).obj ((Opens.map H.hom.base).obj U))) = Y.presheaf.obj (op U)) ≫
        NatTrans.app H.hom.c (op U) =
    𝟙 (X.presheaf.obj (op ((Opens.map H.hom.base).obj U)))
[PROOFSTEP]
erw [eq₂, reassoc_of% eq₁]
[GOAL]
case w
C : Type u_1
inst✝ : Category.{?u.217173, u_1} C
X Y : PresheafedSpace C
H : X ≅ Y
U : Opens ↑↑Y
eq₁ :
  NatTrans.app H.inv.c (op ((Opens.map H.hom.base).obj U)) ≫
      NatTrans.app H.hom.c (op ((Opens.map H.inv.base).obj (op ((Opens.map H.hom.base).obj U)).unop)) =
    eqToHom
      (_ :
        X.presheaf.obj ((Opens.map (𝟙 X).base).op.obj (op ((Opens.map H.hom.base).obj U))) =
          X.presheaf.obj ((Opens.map (H.hom ≫ H.inv).base).op.obj (op ((Opens.map H.hom.base).obj U))))
eq₂ :
  eqToHom
        (_ :
          Y.presheaf.obj (op ((Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U)) =
            Y.presheaf.obj (op ((Opens.map ((forget C).map (𝟙 Y))).obj U))) ≫
      NatTrans.app H.hom.c (op ((Opens.map ((forget C).map (𝟙 Y))).obj U)) =
    NatTrans.app H.hom.c (op ((Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U)) ≫
      (H.hom.base _* X.presheaf).map
        (eqToHom
          (_ : op ((Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U) = op ((Opens.map ((forget C).map (𝟙 Y))).obj U)))
⊢ eqToHom
        (_ :
          X.presheaf.obj ((Opens.map (𝟙 X).base).op.obj (op ((Opens.map H.hom.base).obj U))) =
            X.presheaf.obj ((Opens.map (H.hom ≫ H.inv).base).op.obj (op ((Opens.map H.hom.base).obj U)))) ≫
      (H.hom.base _* X.presheaf).map
        (eqToHom
          (_ :
            op ((Opens.map ((forget C).map (H.inv ≫ H.hom))).obj U) = op ((Opens.map ((forget C).map (𝟙 Y))).obj U))) =
    𝟙 (X.presheaf.obj (op ((Opens.map H.hom.base).obj U)))
[PROOFSTEP]
simp
[GOAL]
C : Type u_1
inst✝ : Category.{?u.242573, u_1} C
U✝ : TopCat
X : PresheafedSpace C
f✝ : U✝ ⟶ ↑X
h : OpenEmbedding ↑f✝
U V : (Opens ↑↑X)ᵒᵖ
f : U ⟶ V
⊢ X.presheaf.map f ≫
      (fun V => X.presheaf.map (NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑f✝)).counit V.unop).op) V =
    (fun V => X.presheaf.map (NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑f✝)).counit V.unop).op) U ≫
      X.presheaf.map ((IsOpenMap.functor (_ : IsOpenMap ↑f✝)).op.map ((Opens.map f✝).op.map f))
[PROOFSTEP]
rw [← map_comp, ← map_comp]
[GOAL]
C : Type u_1
inst✝ : Category.{?u.242573, u_1} C
U✝ : TopCat
X : PresheafedSpace C
f✝ : U✝ ⟶ ↑X
h : OpenEmbedding ↑f✝
U V : (Opens ↑↑X)ᵒᵖ
f : U ⟶ V
⊢ X.presheaf.map (f ≫ (NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑f✝)).counit V.unop).op) =
    X.presheaf.map
      ((NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑f✝)).counit U.unop).op ≫
        (IsOpenMap.functor (_ : IsOpenMap ↑f✝)).op.map ((Opens.map f✝).op.map f))
[PROOFSTEP]
rfl
[GOAL]
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
⊢ Mono (ofRestrict X hf)
[PROOFSTEP]
haveI : Mono f := (TopCat.mono_iff_injective _).mpr hf.inj
[GOAL]
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this : Mono f
⊢ Mono (ofRestrict X hf)
[PROOFSTEP]
constructor
[GOAL]
case right_cancellation
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this : Mono f
⊢ ∀ {Z : PresheafedSpace C} (g h : Z ⟶ restrict X hf), g ≫ ofRestrict X hf = h ≫ ofRestrict X hf → g = h
[PROOFSTEP]
intro Z g₁ g₂ eq
[GOAL]
case right_cancellation
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
⊢ g₁ = g₂
[PROOFSTEP]
ext1
[GOAL]
case right_cancellation.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
⊢ g₁.base = g₂.base
[PROOFSTEP]
have := congr_arg PresheafedSpace.Hom.base eq
[GOAL]
case right_cancellation.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this✝ : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
this : (g₁ ≫ ofRestrict X hf).base = (g₂ ≫ ofRestrict X hf).base
⊢ g₁.base = g₂.base
[PROOFSTEP]
simp only [PresheafedSpace.comp_base, PresheafedSpace.ofRestrict_base] at this
[GOAL]
case right_cancellation.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this✝ : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
this : g₁.base ≫ f = g₂.base ≫ f
⊢ g₁.base = g₂.base
[PROOFSTEP]
rw [cancel_mono] at this
[GOAL]
case right_cancellation.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this✝ : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
this : g₁.base = g₂.base
⊢ g₁.base = g₂.base
[PROOFSTEP]
exact this
[GOAL]
case right_cancellation.h
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
⊢ g₁.c ≫ whiskerRight (eqToHom (_ : (Opens.map g₁.base).op = (Opens.map g₂.base).op)) Z.presheaf = g₂.c
[PROOFSTEP]
ext V
[GOAL]
case right_cancellation.h.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
V : Opens ↑↑(restrict X hf)
⊢ NatTrans.app (g₁.c ≫ whiskerRight (eqToHom (_ : (Opens.map g₁.base).op = (Opens.map g₂.base).op)) Z.presheaf) (op V) =
    NatTrans.app g₂.c (op V)
[PROOFSTEP]
have hV : (Opens.map (X.ofRestrict hf).base).obj (hf.isOpenMap.functor.obj V) = V :=
  by
  ext1
  exact Set.preimage_image_eq _ hf.inj
[GOAL]
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
V : Opens ↑↑(restrict X hf)
⊢ (Opens.map (ofRestrict X hf).base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V) = V
[PROOFSTEP]
ext1
[GOAL]
case h
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
V : Opens ↑↑(restrict X hf)
⊢ ↑((Opens.map (ofRestrict X hf).base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)) = ↑V
[PROOFSTEP]
exact Set.preimage_image_eq _ hf.inj
[GOAL]
case right_cancellation.h.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
V : Opens ↑↑(restrict X hf)
hV : (Opens.map (ofRestrict X hf).base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V) = V
⊢ NatTrans.app (g₁.c ≫ whiskerRight (eqToHom (_ : (Opens.map g₁.base).op = (Opens.map g₂.base).op)) Z.presheaf) (op V) =
    NatTrans.app g₂.c (op V)
[PROOFSTEP]
haveI : IsIso (hf.isOpenMap.adjunction.counit.app (unop (op (hf.isOpenMap.functor.obj V)))) :=
  NatIso.isIso_app_of_isIso (whiskerLeft hf.isOpenMap.functor hf.isOpenMap.adjunction.counit) V
[GOAL]
case right_cancellation.h.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this✝ : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
V : Opens ↑↑(restrict X hf)
hV : (Opens.map (ofRestrict X hf).base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V) = V
this :
  IsIso
    (NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑f)).counit
      (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)
⊢ NatTrans.app (g₁.c ≫ whiskerRight (eqToHom (_ : (Opens.map g₁.base).op = (Opens.map g₂.base).op)) Z.presheaf) (op V) =
    NatTrans.app g₂.c (op V)
[PROOFSTEP]
have := PresheafedSpace.congr_app eq (op (hf.isOpenMap.functor.obj V))
[GOAL]
case right_cancellation.h.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this✝¹ : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
V : Opens ↑↑(restrict X hf)
hV : (Opens.map (ofRestrict X hf).base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V) = V
this✝ :
  IsIso
    (NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑f)).counit
      (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)
this :
  NatTrans.app (g₁ ≫ ofRestrict X hf).c (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)) =
    NatTrans.app (g₂ ≫ ofRestrict X hf).c (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)) ≫
      Z.presheaf.map
        (eqToHom
          (_ :
            (Opens.map (g₂ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)) =
              (Opens.map (g₁ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V))))
⊢ NatTrans.app (g₁.c ≫ whiskerRight (eqToHom (_ : (Opens.map g₁.base).op = (Opens.map g₂.base).op)) Z.presheaf) (op V) =
    NatTrans.app g₂.c (op V)
[PROOFSTEP]
simp only [PresheafedSpace.comp_c_app, PresheafedSpace.ofRestrict_c_app, Category.assoc, cancel_epi] at this
[GOAL]
case right_cancellation.h.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this✝¹ : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
V : Opens ↑↑(restrict X hf)
hV : (Opens.map (ofRestrict X hf).base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V) = V
this✝ :
  IsIso
    (NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑f)).counit
      (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)
this :
  NatTrans.app g₁.c
      (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) =
    NatTrans.app g₂.c
        (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) ≫
      Z.presheaf.map
        (eqToHom
          (_ :
            (Opens.map (g₂ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)) =
              (Opens.map (g₁ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V))))
⊢ NatTrans.app (g₁.c ≫ whiskerRight (eqToHom (_ : (Opens.map g₁.base).op = (Opens.map g₂.base).op)) Z.presheaf) (op V) =
    NatTrans.app g₂.c (op V)
[PROOFSTEP]
have h : _ ≫ _ = _ ≫ _ ≫ _ := congr_arg (fun f => (X.restrict hf).presheaf.map (eqToHom hV).op ≫ f) this
[GOAL]
case right_cancellation.h.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this✝¹ : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
V : Opens ↑↑(restrict X hf)
hV : (Opens.map (ofRestrict X hf).base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V) = V
this✝ :
  IsIso
    (NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑f)).counit
      (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)
this :
  NatTrans.app g₁.c
      (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) =
    NatTrans.app g₂.c
        (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) ≫
      Z.presheaf.map
        (eqToHom
          (_ :
            (Opens.map (g₂ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)) =
              (Opens.map (g₁ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V))))
h :
  (restrict X hf).presheaf.map (eqToHom hV).op ≫
      NatTrans.app g₁.c
        (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) =
    (restrict X hf).presheaf.map (eqToHom hV).op ≫
      NatTrans.app g₂.c
          (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) ≫
        Z.presheaf.map
          (eqToHom
            (_ :
              (Opens.map (g₂ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)) =
                (Opens.map (g₁ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V))))
⊢ NatTrans.app (g₁.c ≫ whiskerRight (eqToHom (_ : (Opens.map g₁.base).op = (Opens.map g₂.base).op)) Z.presheaf) (op V) =
    NatTrans.app g₂.c (op V)
[PROOFSTEP]
erw [g₁.c.naturality, g₂.c.naturality_assoc] at h
[GOAL]
case right_cancellation.h.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this✝¹ : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
V : Opens ↑↑(restrict X hf)
hV : (Opens.map (ofRestrict X hf).base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V) = V
this✝ :
  IsIso
    (NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑f)).counit
      (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)
this :
  NatTrans.app g₁.c
      (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) =
    NatTrans.app g₂.c
        (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) ≫
      Z.presheaf.map
        (eqToHom
          (_ :
            (Opens.map (g₂ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)) =
              (Opens.map (g₁ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V))))
h :
  NatTrans.app g₁.c (op V) ≫ (g₁.base _* Z.presheaf).map (eqToHom hV).op =
    NatTrans.app g₂.c (op V) ≫
      (g₂.base _* Z.presheaf).map (eqToHom hV).op ≫
        Z.presheaf.map
          (eqToHom
            (_ :
              (Opens.map (g₂ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)) =
                (Opens.map (g₁ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V))))
⊢ NatTrans.app (g₁.c ≫ whiskerRight (eqToHom (_ : (Opens.map g₁.base).op = (Opens.map g₂.base).op)) Z.presheaf) (op V) =
    NatTrans.app g₂.c (op V)
[PROOFSTEP]
simp only [Presheaf.pushforwardObj_map, eqToHom_op, Category.assoc, eqToHom_map, eqToHom_trans] at h
[GOAL]
case right_cancellation.h.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this✝¹ : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
V : Opens ↑↑(restrict X hf)
hV : (Opens.map (ofRestrict X hf).base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V) = V
this✝ :
  IsIso
    (NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑f)).counit
      (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)
this :
  NatTrans.app g₁.c
      (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) =
    NatTrans.app g₂.c
        (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) ≫
      Z.presheaf.map
        (eqToHom
          (_ :
            (Opens.map (g₂ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)) =
              (Opens.map (g₁ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V))))
h :
  NatTrans.app g₁.c (op V) ≫
      eqToHom
        (_ :
          Z.presheaf.obj ((Opens.map g₁.base).op.obj (op V)) =
            Z.presheaf.obj
              ((Opens.map g₁.base).op.obj
                (op ((Opens.map (ofRestrict X hf).base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V))))) =
    NatTrans.app g₂.c (op V) ≫
      eqToHom
        (_ :
          (g₂.base _* Z.presheaf).obj (op V) =
            (g₁.base _* Z.presheaf).obj
              (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)))
⊢ NatTrans.app (g₁.c ≫ whiskerRight (eqToHom (_ : (Opens.map g₁.base).op = (Opens.map g₂.base).op)) Z.presheaf) (op V) =
    NatTrans.app g₂.c (op V)
[PROOFSTEP]
rw [← IsIso.comp_inv_eq, inv_eqToHom, Category.assoc, eqToHom_trans] at h
[GOAL]
case right_cancellation.h.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this✝¹ : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
V : Opens ↑↑(restrict X hf)
hV : (Opens.map (ofRestrict X hf).base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V) = V
this✝ :
  IsIso
    (NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑f)).counit
      (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)
this :
  NatTrans.app g₁.c
      (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) =
    NatTrans.app g₂.c
        (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) ≫
      Z.presheaf.map
        (eqToHom
          (_ :
            (Opens.map (g₂ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)) =
              (Opens.map (g₁ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V))))
h :
  NatTrans.app g₁.c (op V) ≫ eqToHom (_ : (g₁.base _* Z.presheaf).obj (op V) = (g₂.base _* Z.presheaf).obj (op V)) =
    NatTrans.app g₂.c (op V)
⊢ NatTrans.app (g₁.c ≫ whiskerRight (eqToHom (_ : (Opens.map g₁.base).op = (Opens.map g₂.base).op)) Z.presheaf) (op V) =
    NatTrans.app g₂.c (op V)
[PROOFSTEP]
rw [NatTrans.comp_app]
[GOAL]
case right_cancellation.h.w
C : Type u_1
inst✝ : Category.{?u.247153, u_1} C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
hf : OpenEmbedding ↑f
this✝¹ : Mono f
Z : PresheafedSpace C
g₁ g₂ : Z ⟶ restrict X hf
eq : g₁ ≫ ofRestrict X hf = g₂ ≫ ofRestrict X hf
V : Opens ↑↑(restrict X hf)
hV : (Opens.map (ofRestrict X hf).base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V) = V
this✝ :
  IsIso
    (NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑f)).counit
      (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)
this :
  NatTrans.app g₁.c
      (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) =
    NatTrans.app g₂.c
        (op ((Opens.map (ofRestrict X hf).base).obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)).unop)) ≫
      Z.presheaf.map
        (eqToHom
          (_ :
            (Opens.map (g₂ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V)) =
              (Opens.map (g₁ ≫ ofRestrict X hf).base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f)).obj V))))
h :
  NatTrans.app g₁.c (op V) ≫ eqToHom (_ : (g₁.base _* Z.presheaf).obj (op V) = (g₂.base _* Z.presheaf).obj (op V)) =
    NatTrans.app g₂.c (op V)
⊢ NatTrans.app g₁.c (op V) ≫
      NatTrans.app (whiskerRight (eqToHom (_ : (Opens.map g₁.base).op = (Opens.map g₂.base).op)) Z.presheaf) (op V) =
    NatTrans.app g₂.c (op V)
[PROOFSTEP]
simpa using h
[GOAL]
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
⊢ (restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).presheaf = (Opens.inclusionTopIso ↑X).inv _* X.presheaf
[PROOFSTEP]
dsimp
[GOAL]
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
⊢ (IsOpenMap.functor (_ : IsOpenMap ↑(Opens.inclusion ⊤))).op ⋙ X.presheaf =
    (Opens.inclusionTopIso ↑X).inv _* X.presheaf
[PROOFSTEP]
rw [Opens.inclusion_top_functor X.carrier]
[GOAL]
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
⊢ (Opens.map (Opens.inclusionTopIso ↑X).inv).op ⋙ X.presheaf = (Opens.inclusionTopIso ↑X).inv _* X.presheaf
[PROOFSTEP]
rfl
[GOAL]
C : Type u_1
inst✝ : Category.{?u.265841, u_1} C
X : PresheafedSpace C
⊢ X.presheaf =
    (ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).base _*
      (restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).presheaf
[PROOFSTEP]
rw [restrict_top_presheaf, ← Presheaf.Pushforward.comp_eq]
[GOAL]
C : Type u_1
inst✝ : Category.{?u.265841, u_1} C
X : PresheafedSpace C
⊢ X.presheaf =
    ((Opens.inclusionTopIso ↑X).inv ≫ (ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).base) _* X.presheaf
[PROOFSTEP]
erw [Iso.inv_hom_id]
[GOAL]
C : Type u_1
inst✝ : Category.{?u.265841, u_1} C
X : PresheafedSpace C
⊢ X.presheaf = 𝟙 ↑X _* X.presheaf
[PROOFSTEP]
rw [Presheaf.Pushforward.id_eq]
[GOAL]
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
⊢ (ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).c =
    eqToHom
      (_ :
        X.presheaf =
          (ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).base _*
            (restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).presheaf)
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
U✝ : Opens ↑↑X
⊢ NatTrans.app (ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).c (op U✝) =
    NatTrans.app
      (eqToHom
        (_ :
          X.presheaf =
            (ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).base _*
              (restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).presheaf))
      (op U✝)
[PROOFSTEP]
dsimp [ofRestrict]
[GOAL]
case w
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
U✝ : Opens ↑↑X
⊢ X.presheaf.map (NatTrans.app (IsOpenMap.adjunction (_ : IsOpenMap ↑(Opens.inclusion ⊤))).counit U✝).op =
    NatTrans.app
      (eqToHom
        (_ :
          X.presheaf = Opens.inclusion ⊤ _* ((IsOpenMap.functor (_ : IsOpenMap ↑(Opens.inclusion ⊤))).op ⋙ X.presheaf)))
      (op U✝)
[PROOFSTEP]
erw [eqToHom_map, eqToHom_app]
[GOAL]
case w.p
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
U✝ : Opens ↑↑X
⊢ op U✝ = op ((IsOpenMap.functor (_ : IsOpenMap ↑(Opens.inclusion ⊤))).obj ((Opens.map (Opens.inclusion ⊤)).obj U✝))
case w.p
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
U✝ : Opens ↑↑X
⊢ op U✝ = op ((IsOpenMap.functor (_ : IsOpenMap ↑(Opens.inclusion ⊤))).obj ((Opens.map (Opens.inclusion ⊤)).obj U✝))
[PROOFSTEP]
simp
[GOAL]
C : Type u_1
inst✝ : Category.{?u.273541, u_1} C
X : PresheafedSpace C
⊢ ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)) ≫ toRestrictTop X =
    𝟙 (restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)))
[PROOFSTEP]
ext
[GOAL]
case w.w
C : Type u_1
inst✝ : Category.{?u.273541, u_1} C
X : PresheafedSpace C
x✝ : (CategoryTheory.forget TopCat).obj ↑(restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)))
⊢ ↑(ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)) ≫ toRestrictTop X).base x✝ =
    ↑(𝟙 (restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)))).base x✝
[PROOFSTEP]
rfl
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.273541, u_1} C
X : PresheafedSpace C
U✝ : Opens ↑↑(restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)))
⊢ NatTrans.app
      ((ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)) ≫ toRestrictTop X).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map (ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)) ≫ toRestrictTop X).base).op =
                (Opens.map (𝟙 (restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)))).base).op))
          (restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).presheaf)
      (op U✝) =
    NatTrans.app (𝟙 (restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)))).c (op U✝)
[PROOFSTEP]
dsimp
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.273541, u_1} C
X : PresheafedSpace C
U✝ : Opens ↑↑(restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)))
⊢ NatTrans.app
      ((ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)) ≫ toRestrictTop X).c ≫
        whiskerRight (𝟙 (Opens.map (Opens.inclusion ⊤ ≫ (Opens.inclusionTopIso ↑X).inv)).op)
          ((IsOpenMap.functor (_ : IsOpenMap ↑(Opens.inclusion ⊤))).op ⋙ X.presheaf))
      (op U✝) =
    NatTrans.app (𝟙 (restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)))).c (op U✝)
[PROOFSTEP]
erw [comp_c, toRestrictTop_c, whiskerRight_id', comp_id, ofRestrict_top_c, eqToHom_map, eqToHom_trans, eqToHom_refl]
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.273541, u_1} C
X : PresheafedSpace C
U✝ : Opens ↑↑(restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)))
⊢ NatTrans.app (𝟙 (restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).presheaf) (op U✝) =
    NatTrans.app (𝟙 (restrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)))).c (op U✝)
[PROOFSTEP]
rfl
[GOAL]
C : Type u_1
inst✝ : Category.{?u.273541, u_1} C
X : PresheafedSpace C
⊢ toRestrictTop X ≫ ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤)) = 𝟙 X
[PROOFSTEP]
ext
[GOAL]
case w.w
C : Type u_1
inst✝ : Category.{?u.273541, u_1} C
X : PresheafedSpace C
x✝ : (CategoryTheory.forget TopCat).obj ↑X
⊢ ↑(toRestrictTop X ≫ ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).base x✝ = ↑(𝟙 X).base x✝
[PROOFSTEP]
rfl
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.273541, u_1} C
X : PresheafedSpace C
U✝ : Opens ↑↑X
⊢ NatTrans.app
      ((toRestrictTop X ≫ ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map (toRestrictTop X ≫ ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).base).op =
                (Opens.map (𝟙 X).base).op))
          X.presheaf)
      (op U✝) =
    NatTrans.app (𝟙 X).c (op U✝)
[PROOFSTEP]
dsimp
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.273541, u_1} C
X : PresheafedSpace C
U✝ : Opens ↑↑X
⊢ NatTrans.app
      ((toRestrictTop X ≫ ofRestrict X (_ : OpenEmbedding ↑(Opens.inclusion ⊤))).c ≫
        whiskerRight (𝟙 (Opens.map ((Opens.inclusionTopIso ↑X).inv ≫ Opens.inclusion ⊤)).op) X.presheaf)
      (op U✝) =
    NatTrans.app (𝟙 X).c (op U✝)
[PROOFSTEP]
erw [comp_c, ofRestrict_top_c, toRestrictTop_c, eqToHom_map, whiskerRight_id', comp_id, eqToHom_trans, eqToHom_refl]
[GOAL]
case h.w
C : Type u_1
inst✝ : Category.{?u.273541, u_1} C
X : PresheafedSpace C
U✝ : Opens ↑↑X
⊢ NatTrans.app (𝟙 X.presheaf) (op U✝) = NatTrans.app (𝟙 X).c (op U✝)
[PROOFSTEP]
rfl
[GOAL]
C : Type u_1
inst✝¹ : Category.{?u.293007, u_1} C
D : Type u_2
inst✝ : Category.{?u.293014, u_2} D
F : C ⥤ D
X : PresheafedSpace C
⊢ { obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
          map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
      (𝟙 X) =
    𝟙
      ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
            map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
        X)
[PROOFSTEP]
ext U
[GOAL]
case w.w
C : Type u_1
inst✝¹ : Category.{?u.293007, u_1} C
D : Type u_2
inst✝ : Category.{?u.293014, u_2} D
F : C ⥤ D
X : PresheafedSpace C
U :
  (forget TopCat).obj
    ↑({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
            map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
        X)
⊢ ↑({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
            (𝟙 X)).base
      U =
    ↑(𝟙
            ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                  map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
              X)).base
      U
case h.w
C : Type u_1
inst✝¹ : Category.{?u.293007, u_1} C
D : Type u_2
inst✝ : Category.{?u.293014, u_2} D
F : C ⥤ D
X : PresheafedSpace C
U :
  Opens
    ↑↑({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
              map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
          X)
⊢ NatTrans.app
      (({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
            (𝟙 X)).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map
                    ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                            map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
                        (𝟙 X)).base).op =
                (Opens.map
                    (𝟙
                        ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                              map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
                          X)).base).op))
          ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                  map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
              X).presheaf)
      (op U) =
    NatTrans.app
      (𝟙
          ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
            X)).c
      (op U)
[PROOFSTEP]
rfl
[GOAL]
case h.w
C : Type u_1
inst✝¹ : Category.{?u.293007, u_1} C
D : Type u_2
inst✝ : Category.{?u.293014, u_2} D
F : C ⥤ D
X : PresheafedSpace C
U :
  Opens
    ↑↑({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
              map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
          X)
⊢ NatTrans.app
      (({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
            (𝟙 X)).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map
                    ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                            map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
                        (𝟙 X)).base).op =
                (Opens.map
                    (𝟙
                        ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                              map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
                          X)).base).op))
          ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                  map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
              X).presheaf)
      (op U) =
    NatTrans.app
      (𝟙
          ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
            X)).c
      (op U)
[PROOFSTEP]
simp
[GOAL]
C : Type u_1
inst✝¹ : Category.{?u.293007, u_1} C
D : Type u_2
inst✝ : Category.{?u.293014, u_2} D
F : C ⥤ D
X✝ Y✝ Z✝ : PresheafedSpace C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
          map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
      (f ≫ g) =
    { obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
            map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
        f ≫
      { obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
            map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
        g
[PROOFSTEP]
ext U
[GOAL]
case w.w
C : Type u_1
inst✝¹ : Category.{?u.293007, u_1} C
D : Type u_2
inst✝ : Category.{?u.293014, u_2} D
F : C ⥤ D
X✝ Y✝ Z✝ : PresheafedSpace C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
U :
  (forget TopCat).obj
    ↑({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
            map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
        X✝)
⊢ ↑({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
            (f ≫ g)).base
      U =
    ↑({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                  map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
              f ≫
            { obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                  map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
              g).base
      U
case h.w
C : Type u_1
inst✝¹ : Category.{?u.293007, u_1} C
D : Type u_2
inst✝ : Category.{?u.293014, u_2} D
F : C ⥤ D
X✝ Y✝ Z✝ : PresheafedSpace C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
U :
  Opens
    ↑↑({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
              map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
          Z✝)
⊢ NatTrans.app
      (({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
            (f ≫ g)).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map
                    ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                            map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
                        (f ≫ g)).base).op =
                (Opens.map
                    ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                              map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
                          f ≫
                        { obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                              map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
                          g).base).op))
          ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                  map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
              X✝).presheaf)
      (op U) =
    NatTrans.app
      ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
            f ≫
          { obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
            g).c
      (op U)
[PROOFSTEP]
rfl
[GOAL]
case h.w
C : Type u_1
inst✝¹ : Category.{?u.293007, u_1} C
D : Type u_2
inst✝ : Category.{?u.293014, u_2} D
F : C ⥤ D
X✝ Y✝ Z✝ : PresheafedSpace C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
U :
  Opens
    ↑↑({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
              map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
          Z✝)
⊢ NatTrans.app
      (({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
            (f ≫ g)).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map
                    ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                            map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
                        (f ≫ g)).base).op =
                (Opens.map
                    ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                              map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
                          f ≫
                        { obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                              map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
                          g).base).op))
          ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                  map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.obj
              X✝).presheaf)
      (op U) =
    NatTrans.app
      ({ obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
            f ≫
          { obj := fun X => { carrier := ↑X, presheaf := X.presheaf ⋙ F },
                map := fun {X Y} f => { base := f.base, c := whiskerRight f.c F } }.map
            g).c
      (op U)
[PROOFSTEP]
simp


[GOAL]
R : Type u
inst✝ : Ring R
M : FGModuleCat R
⊢ AddCommGroup ↑M
[PROOFSTEP]
change AddCommGroup M.obj
[GOAL]
R : Type u
inst✝ : Ring R
M : FGModuleCat R
⊢ AddCommGroup ↑M.obj
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
inst✝ : Ring R
M : FGModuleCat R
⊢ Module R ↑M
[PROOFSTEP]
change Module R M.obj
[GOAL]
R : Type u
inst✝ : Ring R
M : FGModuleCat R
⊢ Module R ↑M.obj
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
inst✝ : Ring R
⊢ LargeCategory (FGModuleCat R)
[PROOFSTEP]
dsimp [FGModuleCat]
[GOAL]
R : Type u
inst✝ : Ring R
⊢ LargeCategory (FullSubcategory fun V => Module.Finite R ↑V)
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
inst✝ : Ring R
⊢ ConcreteCategory (FGModuleCat R)
[PROOFSTEP]
dsimp [FGModuleCat]
[GOAL]
R : Type u
inst✝ : Ring R
⊢ ConcreteCategory (FullSubcategory fun V => Module.Finite R ↑V)
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
inst✝ : Ring R
⊢ Preadditive (FGModuleCat R)
[PROOFSTEP]
dsimp [FGModuleCat]
[GOAL]
R : Type u
inst✝ : Ring R
⊢ Preadditive (FullSubcategory fun V => Module.Finite R ↑V)
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
inst✝³ : Ring R
V : Type u
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : Module.Finite R V
⊢ Module.Finite R ↑(ModuleCat.of R V)
[PROOFSTEP]
change Module.Finite R V
[GOAL]
R : Type u
inst✝³ : Ring R
V : Type u
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : Module.Finite R V
⊢ Module.Finite R V
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
inst✝ : Ring R
⊢ HasForget₂ (FGModuleCat R) (ModuleCat R)
[PROOFSTEP]
dsimp [FGModuleCat]
[GOAL]
R : Type u
inst✝ : Ring R
⊢ HasForget₂ (FullSubcategory fun V => Module.Finite R ↑V) (ModuleCat R)
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
inst✝⁶ : Ring R
V W : Type u
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : Module.Finite R V
inst✝² : AddCommGroup W
inst✝¹ : Module R W
inst✝ : Module.Finite R W
e : V ≃ₗ[R] W
⊢ ↑e ≫ ↑(LinearEquiv.symm e) = 𝟙 (of R V)
[PROOFSTEP]
ext x
[GOAL]
case w
R : Type u
inst✝⁶ : Ring R
V W : Type u
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : Module.Finite R V
inst✝² : AddCommGroup W
inst✝¹ : Module R W
inst✝ : Module.Finite R W
e : V ≃ₗ[R] W
x : (forget (FGModuleCat R)).obj (of R V)
⊢ ↑(↑e ≫ ↑(LinearEquiv.symm e)) x = ↑(𝟙 (of R V)) x
[PROOFSTEP]
exact e.left_inv x
[GOAL]
R : Type u
inst✝⁶ : Ring R
V W : Type u
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : Module.Finite R V
inst✝² : AddCommGroup W
inst✝¹ : Module R W
inst✝ : Module.Finite R W
e : V ≃ₗ[R] W
⊢ ↑(LinearEquiv.symm e) ≫ ↑e = 𝟙 (of R W)
[PROOFSTEP]
ext x
[GOAL]
case w
R : Type u
inst✝⁶ : Ring R
V W : Type u
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : Module.Finite R V
inst✝² : AddCommGroup W
inst✝¹ : Module R W
inst✝ : Module.Finite R W
e : V ≃ₗ[R] W
x : (forget (FGModuleCat R)).obj (of R W)
⊢ ↑(↑(LinearEquiv.symm e) ≫ ↑e) x = ↑(𝟙 (of R W)) x
[PROOFSTEP]
exact e.right_inv x
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ Linear R (FGModuleCat R)
[PROOFSTEP]
dsimp [FGModuleCat]
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ Linear R (FullSubcategory fun V => Module.Finite R ↑V)
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ MonoidalCategory (FGModuleCat R)
[PROOFSTEP]
dsimp [FGModuleCat]
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ MonoidalCategory (FullSubcategory fun V => Module.Finite R ↑V)
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ SymmetricCategory (FGModuleCat R)
[PROOFSTEP]
dsimp [FGModuleCat]
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ SymmetricCategory (FullSubcategory fun V => Module.Finite R ↑V)
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ MonoidalPreadditive (FGModuleCat R)
[PROOFSTEP]
dsimp [FGModuleCat]
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ MonoidalPreadditive (FullSubcategory fun V => Module.Finite R ↑V)
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ MonoidalLinear R (FGModuleCat R)
[PROOFSTEP]
dsimp [FGModuleCat]
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ MonoidalLinear R (FullSubcategory fun V => Module.Finite R ↑V)
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ Faithful (forget₂Monoidal R).toLaxMonoidalFunctor.toFunctor
[PROOFSTEP]
dsimp [forget₂Monoidal]
  -- Porting note: was `infer_instance`
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ Faithful (fullSubcategoryInclusion fun V => Module.Finite R ↑V)
[PROOFSTEP]
exact FullSubcategory.faithful _
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ Functor.Additive (forget₂Monoidal R).toLaxMonoidalFunctor.toFunctor
[PROOFSTEP]
dsimp [forget₂Monoidal]
  -- Porting note: was `infer_instance`
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ Functor.Additive (fullSubcategoryInclusion fun V => Module.Finite R ↑V)
[PROOFSTEP]
exact Functor.fullSubcategoryInclusion_additive _
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ Functor.Linear R (forget₂Monoidal R).toLaxMonoidalFunctor.toFunctor
[PROOFSTEP]
dsimp [forget₂Monoidal]
  -- Porting note: was `infer_instance`
[GOAL]
R : Type u
inst✝ : CommRing R
⊢ Functor.Linear R (fullSubcategoryInclusion fun V => Module.Finite R ↑V)
[PROOFSTEP]
exact Functor.fullSubcategoryInclusionLinear _ _
[GOAL]
K : Type u
inst✝ : Field K
V W : FGModuleCat K
⊢ Module.Finite K (↑V →ₗ[K] ↑W)
[PROOFSTEP]
infer_instance
[GOAL]
K : Type u
inst✝ : Field K
⊢ MonoidalClosed (FGModuleCat K)
[PROOFSTEP]
dsimp [FGModuleCat]
  -- Porting note: was `infer_instance`
[GOAL]
K : Type u
inst✝ : Field K
⊢ MonoidalClosed (FullSubcategory fun V => Module.Finite K ↑V)
[PROOFSTEP]
exact MonoidalCategory.fullMonoidalClosedSubcategory _
[GOAL]
K : Type u
inst✝ : Field K
V W : FGModuleCat K
⊢ (𝟙 (FGModuleCatDual K V) ⊗ FGModuleCatCoevaluation K V) ≫
      (α_ (FGModuleCatDual K V) V (FGModuleCatDual K V)).inv ≫ (FGModuleCatEvaluation K V ⊗ 𝟙 (FGModuleCatDual K V)) =
    (ρ_ (FGModuleCatDual K V)).hom ≫ (λ_ (FGModuleCatDual K V)).inv
[PROOFSTEP]
apply contractLeft_assoc_coevaluation K V
[GOAL]
K : Type u
inst✝ : Field K
V W : FGModuleCat K
⊢ (FGModuleCatCoevaluation K V ⊗ 𝟙 V) ≫ (α_ V (FGModuleCatDual K V) V).hom ≫ (𝟙 V ⊗ FGModuleCatEvaluation K V) =
    (λ_ V).hom ≫ (ρ_ V).inv
[PROOFSTEP]
apply contractLeft_assoc_coevaluation' K V


[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
I : C
hI : IsInitial I
A : C
f g : A ⟶ I
⊢ f = g
[PROOFSTEP]
haveI := hI.isIso_to f
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
I : C
hI : IsInitial I
A : C
f g : A ⟶ I
this : IsIso f
⊢ f = g
[PROOFSTEP]
haveI := hI.isIso_to g
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
I : C
hI : IsInitial I
A : C
f g : A ⟶ I
this✝ : IsIso f
this : IsIso g
⊢ f = g
[PROOFSTEP]
exact eq_of_inv_eq_inv (hI.hom_ext (inv f) (inv g))
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasStrictInitialObjects C
I X : C
inst✝ : HasBinaryProduct X I
hI : IsInitial I
⊢ X ⨯ I ≅ I
[PROOFSTEP]
have := hI.isIso_to (prod.snd : X ⨯ I ⟶ I)
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasStrictInitialObjects C
I X : C
inst✝ : HasBinaryProduct X I
hI : IsInitial I
this : IsIso prod.snd
⊢ X ⨯ I ≅ I
[PROOFSTEP]
exact asIso prod.snd
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasStrictInitialObjects C
I X : C
inst✝ : HasBinaryProduct I X
hI : IsInitial I
⊢ I ⨯ X ≅ I
[PROOFSTEP]
have := hI.isIso_to (prod.fst : I ⨯ X ⟶ I)
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasStrictInitialObjects C
I X : C
inst✝ : HasBinaryProduct I X
hI : IsInitial I
this : IsIso prod.fst
⊢ I ⨯ X ≅ I
[PROOFSTEP]
exact asIso prod.fst
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasInitial C
h : ∀ (A : C) (f : A ⟶ ⊥_ C), IsIso f
I A : C
f : A ⟶ I
hI : IsInitial I
this : IsIso (f ≫ IsInitial.to hI (⊥_ C))
⊢ f ≫ IsInitial.to hI (⊥_ C) ≫ inv (f ≫ IsInitial.to hI (⊥_ C)) = 𝟙 A
[PROOFSTEP]
rw [← assoc, IsIso.hom_inv_id]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictTerminalObjects C
I : C
hI : IsTerminal I
A : C
f g : I ⟶ A
⊢ f = g
[PROOFSTEP]
haveI := hI.isIso_from f
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictTerminalObjects C
I : C
hI : IsTerminal I
A : C
f g : I ⟶ A
this : IsIso f
⊢ f = g
[PROOFSTEP]
haveI := hI.isIso_from g
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictTerminalObjects C
I : C
hI : IsTerminal I
A : C
f g : I ⟶ A
this✝ : IsIso f
this : IsIso g
⊢ f = g
[PROOFSTEP]
exact eq_of_inv_eq_inv (hI.hom_ext (inv f) (inv g))
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
⊢ IsIso (limit.π F i)
[PROOFSTEP]
classical
refine' ⟨⟨limit.lift _ ⟨_, ⟨_, _⟩⟩, _, _⟩⟩
· exact fun j => dite (j = i) (fun h => eqToHom (by cases h; rfl)) fun h => (H _ h).from _
· intro j k f
  split_ifs with h h_1 h_1
  · cases h
    cases h_1
    obtain rfl : f = 𝟙 _ := Subsingleton.elim _ _
    simp
  · cases h
    erw [Category.comp_id]
    haveI : IsIso (F.map f) := (H _ h_1).isIso_from _
    rw [← IsIso.comp_inv_eq]
    apply (H _ h_1).hom_ext
  · cases h_1
    apply (H _ h).hom_ext
  · apply (H _ h).hom_ext
· ext
  rw [assoc, limit.lift_π]
  dsimp only
  split_ifs with h
  · cases h
    rw [id_comp, eqToHom_refl]
    exact comp_id _
  · apply (H _ h).hom_ext
· rw [limit.lift_π]
  simp
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
⊢ IsIso (limit.π F i)
[PROOFSTEP]
refine' ⟨⟨limit.lift _ ⟨_, ⟨_, _⟩⟩, _, _⟩⟩
[GOAL]
case refine'_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
⊢ (X : J) → ((Functor.const J).obj (F.toPrefunctor.1 i)).obj X ⟶ F.obj X
[PROOFSTEP]
exact fun j => dite (j = i) (fun h => eqToHom (by cases h; rfl)) fun h => (H _ h).from _
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j : J
h : j = i
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j = F.obj j
[PROOFSTEP]
cases h
[GOAL]
case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).obj i = F.obj i
[PROOFSTEP]
rfl
[GOAL]
case refine'_2
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
⊢ ∀ ⦃X Y : J⦄ (f : X ⟶ Y),
    (((Functor.const J).obj (F.toPrefunctor.1 i)).map f ≫
        if h : Y = i then eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj Y = F.obj Y)
        else IsTerminal.from (H Y h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj Y)) =
      (if h : X = i then eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj X = F.obj X)
        else IsTerminal.from (H X h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj X)) ≫
        F.map f
[PROOFSTEP]
intro j k f
[GOAL]
case refine'_2
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j k : J
f : j ⟶ k
⊢ (((Functor.const J).obj (F.toPrefunctor.1 i)).map f ≫
      if h : k = i then eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj k = F.obj k)
      else IsTerminal.from (H k h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj k)) =
    (if h : j = i then eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j = F.obj j)
      else IsTerminal.from (H j h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j)) ≫
      F.map f
[PROOFSTEP]
split_ifs with h h_1 h_1
[GOAL]
case pos
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j k : J
f : j ⟶ k
h : k = i
h_1 : j = i
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map f ≫
      eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj k = F.obj k) =
    eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j = F.obj j) ≫ F.map f
[PROOFSTEP]
cases h
[GOAL]
case pos.refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j : J
h_1 : j = i
f : j ⟶ i
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map f ≫
      eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj i = F.obj i) =
    eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j = F.obj j) ≫ F.map f
[PROOFSTEP]
cases h_1
[GOAL]
case pos.refl.refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
f : i ⟶ i
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map f ≫
      eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj i = F.obj i) =
    eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj i = F.obj i) ≫ F.map f
[PROOFSTEP]
obtain rfl : f = 𝟙 _ := Subsingleton.elim _ _
[GOAL]
case pos.refl.refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map (𝟙 i) ≫
      eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj i = F.obj i) =
    eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj i = F.obj i) ≫ F.map (𝟙 i)
[PROOFSTEP]
simp
[GOAL]
case neg
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j k : J
f : j ⟶ k
h : k = i
h_1 : ¬j = i
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map f ≫
      eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj k = F.obj k) =
    IsTerminal.from (H j h_1) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j) ≫ F.map f
[PROOFSTEP]
cases h
[GOAL]
case neg.refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j : J
h_1 : ¬j = i
f : j ⟶ i
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map f ≫
      eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj i = F.obj i) =
    IsTerminal.from (H j h_1) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j) ≫ F.map f
[PROOFSTEP]
erw [Category.comp_id]
[GOAL]
case neg.refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j : J
h_1 : ¬j = i
f : j ⟶ i
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map f =
    IsTerminal.from (H j h_1) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j) ≫ F.map f
[PROOFSTEP]
haveI : IsIso (F.map f) := (H _ h_1).isIso_from _
[GOAL]
case neg.refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j : J
h_1 : ¬j = i
f : j ⟶ i
this : IsIso (F.map f)
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map f =
    IsTerminal.from (H j h_1) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j) ≫ F.map f
[PROOFSTEP]
rw [← IsIso.comp_inv_eq]
[GOAL]
case neg.refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j : J
h_1 : ¬j = i
f : j ⟶ i
this : IsIso (F.map f)
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map f ≫ inv (F.map f) =
    IsTerminal.from (H j h_1) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j)
[PROOFSTEP]
apply (H _ h_1).hom_ext
[GOAL]
case pos
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j k : J
f : j ⟶ k
h : ¬k = i
h_1 : j = i
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map f ≫
      IsTerminal.from (H k h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj k) =
    eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j = F.obj j) ≫ F.map f
[PROOFSTEP]
cases h_1
[GOAL]
case pos.refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
k : J
h : ¬k = i
f : i ⟶ k
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map f ≫
      IsTerminal.from (H k h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj k) =
    eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj i = F.obj i) ≫ F.map f
[PROOFSTEP]
apply (H _ h).hom_ext
[GOAL]
case neg
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j k : J
f : j ⟶ k
h : ¬k = i
h_1 : ¬j = i
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map f ≫
      IsTerminal.from (H k h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj k) =
    IsTerminal.from (H j h_1) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j) ≫ F.map f
[PROOFSTEP]
apply (H _ h).hom_ext
[GOAL]
case refine'_3
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
⊢ limit.π F i ≫
      limit.lift F
        { pt := F.toPrefunctor.1 i,
          π :=
            NatTrans.mk fun j =>
              if h : j = i then eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j = F.obj j)
              else IsTerminal.from (H j h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j) } =
    𝟙 (limit F)
[PROOFSTEP]
ext
[GOAL]
case refine'_3.w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j✝ : J
⊢ (limit.π F i ≫
        limit.lift F
          { pt := F.toPrefunctor.1 i,
            π :=
              NatTrans.mk fun j =>
                if h : j = i then eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j = F.obj j)
                else IsTerminal.from (H j h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j) }) ≫
      limit.π F j✝ =
    𝟙 (limit F) ≫ limit.π F j✝
[PROOFSTEP]
rw [assoc, limit.lift_π]
[GOAL]
case refine'_3.w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j✝ : J
⊢ limit.π F i ≫
      NatTrans.app
        { pt := F.toPrefunctor.1 i,
            π :=
              NatTrans.mk fun j =>
                if h : j = i then eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j = F.obj j)
                else IsTerminal.from (H j h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j) }.π
        j✝ =
    𝟙 (limit F) ≫ limit.π F j✝
[PROOFSTEP]
dsimp only
[GOAL]
case refine'_3.w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j✝ : J
⊢ (limit.π F i ≫
      if h : j✝ = i then eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j✝ = F.obj j✝)
      else IsTerminal.from (H j✝ h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j✝)) =
    𝟙 (limit F) ≫ limit.π F j✝
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j✝ : J
h : j✝ = i
⊢ limit.π F i ≫ eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j✝ = F.obj j✝) =
    𝟙 (limit F) ≫ limit.π F j✝
[PROOFSTEP]
cases h
[GOAL]
case pos.refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
⊢ limit.π F i ≫ eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj i = F.obj i) = 𝟙 (limit F) ≫ limit.π F i
[PROOFSTEP]
rw [id_comp, eqToHom_refl]
[GOAL]
case pos.refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
⊢ limit.π F i ≫ 𝟙 (((Functor.const J).obj (F.toPrefunctor.1 i)).obj i) = limit.π F i
[PROOFSTEP]
exact comp_id _
[GOAL]
case neg
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
j✝ : J
h : ¬j✝ = i
⊢ limit.π F i ≫ IsTerminal.from (H j✝ h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j✝) =
    𝟙 (limit F) ≫ limit.π F j✝
[PROOFSTEP]
apply (H _ h).hom_ext
[GOAL]
case refine'_4
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
⊢ limit.lift F
        { pt := F.toPrefunctor.1 i,
          π :=
            NatTrans.mk fun j =>
              if h : j = i then eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j = F.obj j)
              else IsTerminal.from (H j h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j) } ≫
      limit.π F i =
    𝟙 (F.obj i)
[PROOFSTEP]
rw [limit.lift_π]
[GOAL]
case refine'_4
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
I : C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
⊢ NatTrans.app
      { pt := F.toPrefunctor.1 i,
          π :=
            NatTrans.mk fun j =>
              if h : j = i then eqToHom (_ : ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j = F.obj j)
              else IsTerminal.from (H j h) (((Functor.const J).obj (F.toPrefunctor.1 i)).obj j) }.π
      i =
    𝟙 (F.obj i)
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
I : C
h : ∀ (A : C) (f : I ⟶ A), IsIso f
I' A : C
f : I' ⟶ A
hI' : IsTerminal I'
this : IsIso (IsTerminal.from hI' I ≫ f)
⊢ (inv (IsTerminal.from hI' I ≫ f) ≫ IsTerminal.from hI' I) ≫ f = 𝟙 A
[PROOFSTEP]
rw [assoc, IsIso.inv_hom_id]