awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Module: Mathlib.Geometry.RingedSpace.SheafedSpace
Goal:
C : Type u
inst : Category.{v, u} C
FC : C → C → Type u_1
CC : C → Type v
inst_1 : (X Y : C) → FunLike.{u_1 + 1, v + 1, v + 1} (FC X Y) (CC X) (CC Y)
instCC : ConcreteCategory C FC (CC := CC)
inst_2 : HasColimits.{v, u} C
inst_3 : HasLimits.{v, u} C
inst_4 : PreservesLimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesFilteredColimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_6 : ReflectsIsomorphisms (CategoryTheory.forget C (FC := FC) (CC := CC))
X Y : SheafedSpace.{u, v, v} C
f : (↑X.toPresheafedSpace : TopCat) ⟶ (↑Y.toPresheafedSpace : TopCat)
fc : Y.presheaf ⟶ obj (pushforward C f) X.presheaf
g : (↑X.toPresheafedSpace : TopCat) ⟶ (↑Y.toPresheafedSpace : TopCat)
gc : Y.presheaf ⟶ obj (pushforward C g) X.presheaf
h :
  Eq.{v + 1} (α := (↑X.toPresheafedSpace : TopCat) ⟶ (↑Y.toPresheafedSpace : TopCat))
    (PresheafedSpace.Hom.base (InducedCategory.Hom.hom { hom := { base := f, c := fc } }))
    (PresheafedSpace.Hom.base (InducedCategory.Hom.hom { hom := { base := g, c := gc } }))
h' :
  ∀ (x : (↑(↑X.toPresheafedSpace : TopCat) : Type v)),
    Eq (α :=
      Y.presheaf.stalk
          ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier) (X :=
                (↑X.toPresheafedSpace : TopCat)) (Y := (↑Y.toPresheafedSpace : TopCat))
                (PresheafedSpace.Hom.base
                  (InducedCategory.Hom.hom
                    { hom := { base := f, c := fc : X.Hom Y.toPresheafedSpace } :
                      InducedCategory.Hom (D := PresheafedSpace.{v, u, v} C) (F := toPresheafedSpace) X Y })) :
              (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
            x) ⟶
        X.presheaf.stalk x)
      (PresheafedSpace.Hom.stalkMap (InducedCategory.Hom.hom { hom := { base := f, c := fc } }) x)
      (CategoryStruct.comp (Y :=
        Y.presheaf.stalk
          ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier) (X :=
                (↑X.toPresheafedSpace : TopCat)) (Y := (↑Y.toPresheafedSpace : TopCat))
                (PresheafedSpace.Hom.base (InducedCategory.Hom.hom { hom := { base := g, c := gc } })) :
              (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
            x))
        (Iso.hom (Y.presheaf.stalkCongr ⋯))
        (PresheafedSpace.Hom.stalkMap (InducedCategory.Hom.hom { hom := { base := g, c := gc } }) x))
⊢ f = g

Tactic:
h
-- Module: Mathlib.Geometry.RingedSpace.SheafedSpace
Goal:
C : Type u
inst : Category.{v, u} C
FC : C → C → Type u_1
CC : C → Type v
inst_1 : (X Y : C) → FunLike.{u_1 + 1, v + 1, v + 1} (FC X Y) (CC X) (CC Y)
instCC : ConcreteCategory C FC (CC := CC)
inst_2 : HasColimits.{v, u} C
inst_3 : HasLimits.{v, u} C
inst_4 : PreservesLimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesFilteredColimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_6 : ReflectsIsomorphisms (CategoryTheory.forget C (FC := FC) (CC := CC))
X Y : SheafedSpace.{u, v, v} C
f : (↑X.toPresheafedSpace : TopCat) ⟶ (↑Y.toPresheafedSpace : TopCat)
fc gc : Y.presheaf ⟶ obj (pushforward C f) X.presheaf
h' :
  ∀ (x : (↑(↑X.toPresheafedSpace : TopCat) : Type v)),
    Eq (α :=
      Y.presheaf.stalk
          ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier) (X :=
                (↑X.toPresheafedSpace : TopCat)) (Y := (↑Y.toPresheafedSpace : TopCat))
                (PresheafedSpace.Hom.base
                  (InducedCategory.Hom.hom
                    { hom := { base := f, c := fc : X.Hom Y.toPresheafedSpace } :
                      InducedCategory.Hom (D := PresheafedSpace.{v, u, v} C) (F := toPresheafedSpace) X Y })) :
              (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
            x) ⟶
        X.presheaf.stalk x)
      (PresheafedSpace.Hom.stalkMap (InducedCategory.Hom.hom { hom := { base := f, c := fc } }) x)
      (CategoryStruct.comp (Y :=
        Y.presheaf.stalk
          ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier) (X :=
                (↑X.toPresheafedSpace : TopCat)) (Y := (↑Y.toPresheafedSpace : TopCat))
                (PresheafedSpace.Hom.base (InducedCategory.Hom.hom { hom := { base := f, c := gc } })) :
              (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
            x))
        (Iso.hom (Y.presheaf.stalkCongr ⋯))
        (PresheafedSpace.Hom.stalkMap (InducedCategory.Hom.hom { hom := { base := f, c := gc } }) x))
e_hom : fc = gc
⊢ Eq.{v + 1} (α := X ⟶ Y) { hom := { base := f, c := fc } } { hom := { base := f, c := gc } }

Tactic:
congr
-- Module: Mathlib.Geometry.RingedSpace.SheafedSpace
Goal:
C : Type u
inst : Category.{v, u} C
FC : C → C → Type u_1
CC : C → Type v
inst_1 : (X Y : C) → FunLike.{u_1 + 1, v + 1, v + 1} (FC X Y) (CC X) (CC Y)
instCC : ConcreteCategory C FC (CC := CC)
inst_2 : HasColimits.{v, u} C
inst_3 : HasLimits.{v, u} C
inst_4 : PreservesLimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesFilteredColimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_6 : ReflectsIsomorphisms (CategoryTheory.forget C (FC := FC) (CC := CC))
X Y : SheafedSpace.{u, v, v} C
f : (↑X.toPresheafedSpace : TopCat) ⟶ (↑Y.toPresheafedSpace : TopCat)
fc gc : Y.presheaf ⟶ obj (pushforward C f) X.presheaf
h' :
  ∀ (x : (↑(↑X.toPresheafedSpace : TopCat) : Type v)),
    Eq (α :=
      Y.presheaf.stalk
          ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier) (X :=
                (↑X.toPresheafedSpace : TopCat)) (Y := (↑Y.toPresheafedSpace : TopCat))
                (PresheafedSpace.Hom.base
                  (InducedCategory.Hom.hom
                    { hom := { base := f, c := fc : X.Hom Y.toPresheafedSpace } :
                      InducedCategory.Hom (D := PresheafedSpace.{v, u, v} C) (F := toPresheafedSpace) X Y })) :
              (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
            x) ⟶
        X.presheaf.stalk x)
      (PresheafedSpace.Hom.stalkMap (InducedCategory.Hom.hom { hom := { base := f, c := fc } }) x)
      (CategoryStruct.comp (Y :=
        Y.presheaf.stalk
          ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier) (X :=
                (↑X.toPresheafedSpace : TopCat)) (Y := (↑Y.toPresheafedSpace : TopCat))
                (PresheafedSpace.Hom.base (InducedCategory.Hom.hom { hom := { base := f, c := gc } })) :
              (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
            x))
        (Iso.hom (Y.presheaf.stalkCongr ⋯))
        (PresheafedSpace.Hom.stalkMap (InducedCategory.Hom.hom { hom := { base := f, c := gc } }) x))
e_hom :
  ∀ (U : Opens (↑(↑Y.toPresheafedSpace : TopCat) : Type v)) (s : CC (Y.presheaf.obj (op U))),
    Eq (α := CC ((obj (pushforward C f) X.presheaf).obj (op U)))
      ((ConcreteCategory.hom (FC := FC) (CC := CC) (fc.app (op U)) :
            (a : CC (Y.presheaf.obj (op U))) → CC (((pushforward C f).obj X.presheaf).obj (op U)))
          s :
        CC ((obj (pushforward C f) X.presheaf).obj (op U)))
      ((ConcreteCategory.hom (FC := FC) (CC := CC) (gc.app (op U)) :
            (a : CC (Y.presheaf.obj (op U))) → CC (((pushforward C f).obj X.presheaf).obj (op U)))
          s :
        CC ((obj (pushforward C f) X.presheaf).obj (op U)))
⊢ fc = gc

Tactic:
ext U s
-- Module: Mathlib.Geometry.RingedSpace.SheafedSpace
Goal:
C : Type u
inst : Category.{v, u} C
FC : C → C → Type u_1
CC : C → Type v
inst_1 : (X Y : C) → FunLike.{u_1 + 1, v + 1, v + 1} (FC X Y) (CC X) (CC Y)
instCC : ConcreteCategory C FC (CC := CC)
inst_2 : HasColimits.{v, u} C
inst_3 : HasLimits.{v, u} C
inst_4 : PreservesLimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesFilteredColimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_6 : ReflectsIsomorphisms (CategoryTheory.forget C (FC := FC) (CC := CC))
X Y : SheafedSpace.{u, v, v} C
f : (↑X.toPresheafedSpace : TopCat) ⟶ (↑Y.toPresheafedSpace : TopCat)
fc gc : Y.presheaf ⟶ obj (pushforward C f) X.presheaf
h' :
  ∀ (x : (↑(↑X.toPresheafedSpace : TopCat) : Type v)),
    Eq (α :=
      Y.presheaf.stalk
          ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier) (X :=
                (↑X.toPresheafedSpace : TopCat)) (Y := (↑Y.toPresheafedSpace : TopCat))
                (PresheafedSpace.Hom.base
                  (InducedCategory.Hom.hom
                    { hom := { base := f, c := fc : X.Hom Y.toPresheafedSpace } :
                      InducedCategory.Hom (D := PresheafedSpace.{v, u, v} C) (F := toPresheafedSpace) X Y })) :
              (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
            x) ⟶
        X.presheaf.stalk x)
      (PresheafedSpace.Hom.stalkMap (InducedCategory.Hom.hom { hom := { base := f, c := fc } }) x)
      (CategoryStruct.comp (Y :=
        Y.presheaf.stalk
          ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier) (X :=
                (↑X.toPresheafedSpace : TopCat)) (Y := (↑Y.toPresheafedSpace : TopCat))
                (PresheafedSpace.Hom.base (InducedCategory.Hom.hom { hom := { base := f, c := gc } })) :
              (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
            x))
        (Iso.hom (Y.presheaf.stalkCongr ⋯))
        (PresheafedSpace.Hom.stalkMap (InducedCategory.Hom.hom { hom := { base := f, c := gc } }) x))
U : Opens (↑(↑Y.toPresheafedSpace : TopCat) : Type v)
s : CC (Y.presheaf.obj (op U))
⊢ Eq (α := CC ((obj (pushforward C f) X.presheaf).obj (op U)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC) (fc.app (op U)) :
          (a : CC (Y.presheaf.obj (op U))) → CC (((pushforward C f).obj X.presheaf).obj (op U)))
        s :
      CC ((obj (pushforward C f) X.presheaf).obj (op U)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC) (gc.app (op U)) :
          (a : CC (Y.presheaf.obj (op U))) → CC (((pushforward C f).obj X.presheaf).obj (op U)))
        s :
      CC ((obj (pushforward C f) X.presheaf).obj (op U)))

Tactic:
section_ext X.sheaf _ _ _ fun x hx ↦
    show X.presheaf.germ _ x _ _ = X.presheaf.germ _ x _ _ from ?_

Premises used: AlgebraicGeometry.SheafedSpace.sheaf, TopCat.Presheaf.section_ext
-- Module: Mathlib.Geometry.RingedSpace.SheafedSpace
Goal:
C : Type u
inst : Category.{v, u} C
FC : C → C → Type u_1
CC : C → Type v
inst_1 : (X Y : C) → FunLike.{u_1 + 1, v + 1, v + 1} (FC X Y) (CC X) (CC Y)
instCC : ConcreteCategory C FC (CC := CC)
inst_2 : HasColimits.{v, u} C
inst_3 : HasLimits.{v, u} C
inst_4 : PreservesLimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesFilteredColimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_6 : ReflectsIsomorphisms (CategoryTheory.forget C (FC := FC) (CC := CC))
X Y : SheafedSpace.{u, v, v} C
f : X ⟶ Y
h₁ :
  Function.Injective (α := (↑(↑X.toPresheafedSpace : TopCat) : Type v)) (β :=
    (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
          f.hom.base) :
      (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
h₂ :
  ∀ (x : (↑(↑X.toPresheafedSpace : TopCat) : Type v)),
    Epi (X :=
      Y.presheaf.stalk
        ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
              f.hom.base :
            (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
          x))
      (PresheafedSpace.Hom.stalkMap f.hom x)
right_cancellation : ∀ {Z : SheafedSpace.{u, v, v} C} (g h : Z ⟶ X), g ≫ f = h ≫ f → g = h
⊢ Mono f

Tactic:
constructor
-- Module: Mathlib.Geometry.RingedSpace.SheafedSpace
Goal:
C : Type u
inst : Category.{v, u} C
FC : C → C → Type u_1
CC : C → Type v
inst_1 : (X Y : C) → FunLike.{u_1 + 1, v + 1, v + 1} (FC X Y) (CC X) (CC Y)
instCC : ConcreteCategory C FC (CC := CC)
inst_2 : HasColimits.{v, u} C
inst_3 : HasLimits.{v, u} C
inst_4 : PreservesLimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesFilteredColimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_6 : ReflectsIsomorphisms (CategoryTheory.forget C (FC := FC) (CC := CC))
X Y : SheafedSpace.{u, v, v} C
f : X ⟶ Y
h₁ :
  Function.Injective (α := (↑(↑X.toPresheafedSpace : TopCat) : Type v)) (β :=
    (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
          f.hom.base) :
      (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
h₂ :
  ∀ (x : (↑(↑X.toPresheafedSpace : TopCat) : Type v)),
    Epi (X :=
      Y.presheaf.stalk
        ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
              f.hom.base :
            (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
          x))
      (PresheafedSpace.Hom.stalkMap f.hom x)
Z : SheafedSpace.{u, v, v} C
right_cancellation :
  ∀ (g : (↑Z.toPresheafedSpace : TopCat) ⟶ (↑X.toPresheafedSpace : TopCat))
    (gc : X.presheaf ⟶ obj (pushforward C g) Z.presheaf) (h : Z ⟶ X),
    { hom := { base := g, c := gc } } ≫ f = h ≫ f → { hom := { base := g, c := gc } } = h
⊢ ∀ (g h : Z ⟶ X), g ≫ f = h ≫ f → g = h

Tactic:
⟨g, gc⟩
-- Module: Mathlib.Geometry.RingedSpace.SheafedSpace
Goal:
C : Type u
inst : Category.{v, u} C
FC : C → C → Type u_1
CC : C → Type v
inst_1 : (X Y : C) → FunLike.{u_1 + 1, v + 1, v + 1} (FC X Y) (CC X) (CC Y)
instCC : ConcreteCategory C FC (CC := CC)
inst_2 : HasColimits.{v, u} C
inst_3 : HasLimits.{v, u} C
inst_4 : PreservesLimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesFilteredColimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_6 : ReflectsIsomorphisms (CategoryTheory.forget C (FC := FC) (CC := CC))
X Y : SheafedSpace.{u, v, v} C
f : X ⟶ Y
h₁ :
  Function.Injective (α := (↑(↑X.toPresheafedSpace : TopCat) : Type v)) (β :=
    (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
          f.hom.base) :
      (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
h₂ :
  ∀ (x : (↑(↑X.toPresheafedSpace : TopCat) : Type v)),
    Epi (X :=
      Y.presheaf.stalk
        ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
              f.hom.base :
            (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
          x))
      (PresheafedSpace.Hom.stalkMap f.hom x)
Z : SheafedSpace.{u, v, v} C
g : (↑Z.toPresheafedSpace : TopCat) ⟶ (↑X.toPresheafedSpace : TopCat)
gc : X.presheaf ⟶ obj (pushforward C g) Z.presheaf
right_cancellation :
  ∀ (h : (↑Z.toPresheafedSpace : TopCat) ⟶ (↑X.toPresheafedSpace : TopCat))
    (hc : X.presheaf ⟶ obj (pushforward C h) Z.presheaf),
    Eq (α := Z ⟶ Y) ({ hom := { base := g, c := gc } } ≫ f) ({ hom := { base := h, c := hc } } ≫ f) →
      Eq.{v + 1} (α := Z ⟶ X) { hom := { base := g, c := gc } } { hom := { base := h, c := hc } }
⊢ ∀ (h : Z ⟶ X), { hom := { base := g, c := gc } } ≫ f = h ≫ f → { hom := { base := g, c := gc } } = h

Tactic:
⟨h, hc⟩
-- Module: Mathlib.Geometry.RingedSpace.SheafedSpace
Goal:
C : Type u
inst : Category.{v, u} C
FC : C → C → Type u_1
CC : C → Type v
inst_1 : (X Y : C) → FunLike.{u_1 + 1, v + 1, v + 1} (FC X Y) (CC X) (CC Y)
instCC : ConcreteCategory C FC (CC := CC)
inst_2 : HasColimits.{v, u} C
inst_3 : HasLimits.{v, u} C
inst_4 : PreservesLimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesFilteredColimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_6 : ReflectsIsomorphisms (CategoryTheory.forget C (FC := FC) (CC := CC))
X Y : SheafedSpace.{u, v, v} C
f : X ⟶ Y
h₁ :
  Function.Injective (α := (↑(↑X.toPresheafedSpace : TopCat) : Type v)) (β :=
    (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
          f.hom.base) :
      (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
h₂ :
  ∀ (x : (↑(↑X.toPresheafedSpace : TopCat) : Type v)),
    Epi (X :=
      Y.presheaf.stalk
        ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
              f.hom.base :
            (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
          x))
      (PresheafedSpace.Hom.stalkMap f.hom x)
Z : SheafedSpace.{u, v, v} C
g : (↑Z.toPresheafedSpace : TopCat) ⟶ (↑X.toPresheafedSpace : TopCat)
gc : X.presheaf ⟶ obj (pushforward C g) Z.presheaf
h : (↑Z.toPresheafedSpace : TopCat) ⟶ (↑X.toPresheafedSpace : TopCat)
hc : X.presheaf ⟶ obj (pushforward C h) Z.presheaf
e : Eq (α := Z ⟶ Y) ({ hom := { base := g, c := gc } } ≫ f) ({ hom := { base := h, c := hc } } ≫ f)
⊢ g = h

Tactic:
ConcreteCategory.hom_ext _ _ fun x ↦ h₁ congr(($e).hom.base x)

Premises used: congrArg, CategoryTheory.ConcreteCategory.hom, id, AlgebraicGeometry.PresheafedSpace.Hom.base, CategoryTheory.ConcreteCategory.hom_ext, CategoryTheory.InducedCategory.Hom.hom, DFunLike.coe
-- Module: Mathlib.Geometry.RingedSpace.SheafedSpace
Goal:
C : Type u
inst : Category.{v, u} C
FC : C → C → Type u_1
CC : C → Type v
inst_1 : (X Y : C) → FunLike.{u_1 + 1, v + 1, v + 1} (FC X Y) (CC X) (CC Y)
instCC : ConcreteCategory C FC (CC := CC)
inst_2 : HasColimits.{v, u} C
inst_3 : HasLimits.{v, u} C
inst_4 : PreservesLimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesFilteredColimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_6 : ReflectsIsomorphisms (CategoryTheory.forget C (FC := FC) (CC := CC))
X Y : SheafedSpace.{u, v, v} C
f : X ⟶ Y
h₁ :
  Function.Injective (α := (↑(↑X.toPresheafedSpace : TopCat) : Type v)) (β :=
    (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
          f.hom.base) :
      (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
h₂ :
  ∀ (x : (↑(↑X.toPresheafedSpace : TopCat) : Type v)),
    Epi (X :=
      Y.presheaf.stalk
        ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
              f.hom.base :
            (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
          x))
      (PresheafedSpace.Hom.stalkMap f.hom x)
Z : SheafedSpace.{u, v, v} C
g : (↑Z.toPresheafedSpace : TopCat) ⟶ (↑X.toPresheafedSpace : TopCat)
gc : X.presheaf ⟶ obj (pushforward C g) Z.presheaf
h : (↑Z.toPresheafedSpace : TopCat) ⟶ (↑X.toPresheafedSpace : TopCat)
hc : X.presheaf ⟶ obj (pushforward C h) Z.presheaf
e : Eq (α := Z ⟶ Y) ({ hom := { base := g, c := gc } } ≫ f) ({ hom := { base := h, c := hc } } ≫ f)
right_cancellation :
  ∀ (hc : X.presheaf ⟶ obj (pushforward C g) Z.presheaf)
    (e : Eq (α := Z ⟶ Y) ({ hom := { base := g, c := gc } } ≫ f) ({ hom := { base := g, c := hc } } ≫ f)),
    Eq.{v + 1} (α := Z ⟶ X) { hom := { base := g, c := gc } } { hom := { base := g, c := hc } }
⊢ Eq.{v + 1} (α := Z ⟶ X) { hom := { base := g, c := gc } } { hom := { base := h, c := hc } }

Tactic:
obtain rfl : g = h := ConcreteCategory.hom_ext _ _ fun x ↦ h₁ congr(($e).hom.base x)

Premises used: congrArg, CategoryTheory.ConcreteCategory.hom, id, AlgebraicGeometry.PresheafedSpace.Hom.base, CategoryTheory.ConcreteCategory.hom_ext, CategoryTheory.InducedCategory.Hom.hom, DFunLike.coe, rfl
-- Module: Mathlib.Geometry.RingedSpace.SheafedSpace
Goal:
C : Type u
inst : Category.{v, u} C
FC : C → C → Type u_1
CC : C → Type v
inst_1 : (X Y : C) → FunLike.{u_1 + 1, v + 1, v + 1} (FC X Y) (CC X) (CC Y)
instCC : ConcreteCategory C FC (CC := CC)
inst_2 : HasColimits.{v, u} C
inst_3 : HasLimits.{v, u} C
inst_4 : PreservesLimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesFilteredColimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_6 : ReflectsIsomorphisms (CategoryTheory.forget C (FC := FC) (CC := CC))
X Y : SheafedSpace.{u, v, v} C
f : X ⟶ Y
h₁ :
  Function.Injective (α := (↑(↑X.toPresheafedSpace : TopCat) : Type v)) (β :=
    (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
          f.hom.base) :
      (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
h₂ :
  ∀ (x : (↑(↑X.toPresheafedSpace : TopCat) : Type v)),
    Epi (X :=
      Y.presheaf.stalk
        ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
              f.hom.base :
            (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
          x))
      (PresheafedSpace.Hom.stalkMap f.hom x)
Z : SheafedSpace.{u, v, v} C
g : (↑Z.toPresheafedSpace : TopCat) ⟶ (↑X.toPresheafedSpace : TopCat)
gc hc : X.presheaf ⟶ obj (pushforward C g) Z.presheaf
e : Eq (α := Z ⟶ Y) ({ hom := { base := g, c := gc } } ≫ f) ({ hom := { base := g, c := hc } } ≫ f)
⊢ Eq.{v + 1} (α := Z ⟶ X) { hom := { base := g, c := gc } } { hom := { base := g, c := hc } }

Tactic:
SheafedSpace.hom_stalk_ext ⟨g, gc⟩ ⟨g, hc⟩ rfl fun x ↦ ?_

Premises used: AlgebraicGeometry.PresheafedSpace.Hom.mk, AlgebraicGeometry.SheafedSpace.hom_stalk_ext, CategoryTheory.InducedCategory.Hom.mk, rfl
-- Module: Mathlib.Geometry.RingedSpace.SheafedSpace
Goal:
C : Type u
inst : Category.{v, u} C
FC : C → C → Type u_1
CC : C → Type v
inst_1 : (X Y : C) → FunLike.{u_1 + 1, v + 1, v + 1} (FC X Y) (CC X) (CC Y)
instCC : ConcreteCategory C FC (CC := CC)
inst_2 : HasColimits.{v, u} C
inst_3 : HasLimits.{v, u} C
inst_4 : PreservesLimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesFilteredColimits (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_6 : ReflectsIsomorphisms (CategoryTheory.forget C (FC := FC) (CC := CC))
X Y : SheafedSpace.{u, v, v} C
f : X ⟶ Y
h₁ :
  Function.Injective (α := (↑(↑X.toPresheafedSpace : TopCat) : Type v)) (β :=
    (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
          f.hom.base) :
      (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
h₂ :
  ∀ (x : (↑(↑X.toPresheafedSpace : TopCat) : Type v)),
    Epi (X :=
      Y.presheaf.stalk
        ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{v}) ↦ C((↑X : Type v), (↑Y : Type v))) (CC := carrier)
              f.hom.base :
            (a : (↑(↑X.toPresheafedSpace : TopCat) : Type v)) → (↑(↑Y.toPresheafedSpace : TopCat) : Type v))
          x))
      (PresheafedSpace.Hom.stalkMap f.hom x)
Z : SheafedSpace.{u, v, v} C
g : (↑Z.toPresheafedSpace : TopCat) ⟶ (↑X.toPresheafedSpace : TopCat)
gc hc : X.presheaf ⟶ obj (pushforward C g) Z.presheaf
e : Eq (α := Z ⟶ Y) ({ hom := { base := g, c := gc } } ≫ f) ({ hom := { base := g, c := hc } } ≫ f)
x : (↑(↑Z.toPresheafedSpace : TopCat) : Type v)
⊢ Eq (α := Z.toPresheafedSpace ⟶ Y.toPresheafedSpace) (InducedCategory.Hom.hom ({ hom := { base := g, c := gc } } ≫ f))
    (InducedCategory.Hom.hom ({ hom := { base := g, c := hc } } ≫ f))

Tactic:
replace e := congr_arg InducedCategory.Hom.hom e