-- Mathlib/CategoryTheory/Sites/Over.lean
@[simp]
lemma functorPushforward_over_map {X Y : C} (f : X ⟶ Y) (Z : Over X) (S : Sieve Z.left) :
    Sieve.functorPushforward (Over.map f) ((Sieve.overEquiv Z).symm S) =
      (Sieve.overEquiv ((Over.map f).obj Z)).symm S

Proof state:
case h
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
W : Over Y
g : W ⟶ (Over.map f).obj Z
⊢ (functorPushforward (Over.map f) ((overEquiv Z).symm S)).arrows g ↔ ((overEquiv ((Over.map f).obj Z)).symm S).arrows g

Tactic:
constructor

Result:
case h.mp
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
W : Over Y
g : W ⟶ (Over.map f).obj Z
⊢ (functorPushforward (Over.map f) ((overEquiv Z).symm S)).arrows g → ((overEquiv ((Over.map f).obj Z)).symm S).arrows g

case h.mpr
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
W : Over Y
g : W ⟶ (Over.map f).obj Z
⊢ ((overEquiv ((Over.map f).obj Z)).symm S).arrows g → (functorPushforward (Over.map f) ((overEquiv Z).symm S)).arrows g

Proof state:
case h.mp
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
W : Over Y
g : W ⟶ (Over.map f).obj Z
⊢ (functorPushforward (Over.map f) ((overEquiv Z).symm S)).arrows g → ((overEquiv ((Over.map f).obj Z)).symm S).arrows g

Tactic:
rintro ⟨T, a, b, ha, rfl⟩

Result:
case h.mp.intro.intro.intro.intro
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
W : Over Y
T : Over X
a : T ⟶ Z
b : W ⟶ (Over.map f).obj T
ha : ((overEquiv Z).symm S).arrows a
⊢ ((overEquiv ((Over.map f).obj Z)).symm S).arrows (b ≫ (Over.map f).map a)

Proof state:
case h.mpr
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
W : Over Y
g : W ⟶ (Over.map f).obj Z
hg : ((overEquiv ((Over.map f).obj Z)).symm S).arrows g
⊢ (functorPushforward (Over.map f) ((overEquiv Z).symm S)).arrows g

Tactic:
exact ⟨Over.mk (g.left ≫ Z.hom), Over.homMk g.left,
  Over.homMk (𝟙 _) (by simpa using Over.w g), hg, by aesop_cat⟩

Result:
no goals

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
⊢ functorPushforward (Over.map f) ((overEquiv Z).symm S) = (overEquiv ((Over.map f).obj Z)).symm S

Tactic:
ext W g

Result:
case h
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
W : Over Y
g : W ⟶ (Over.map f).obj Z
⊢ (functorPushforward (Over.map f) ((overEquiv Z).symm S)).arrows g ↔ ((overEquiv ((Over.map f).obj Z)).symm S).arrows g

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
W : Over Y
g : W ⟶ (Over.map f).obj Z
hg : ((overEquiv ((Over.map f).obj Z)).symm S).arrows g
⊢ g = Over.homMk (𝟙 W.left) ⋯ ≫ (Over.map f).map (Over.homMk g.left ⋯)

Tactic:
aesop_cat

Result:
no goals

Proof state:
case h.mp.intro.intro.intro.intro
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
W : Over Y
T : Over X
a : T ⟶ Z
b : W ⟶ (Over.map f).obj T
ha : ((overEquiv Z).symm S).arrows a
⊢ ((overEquiv ((Over.map f).obj Z)).symm S).arrows (b ≫ (Over.map f).map a)

Tactic:
exact S.downward_closed ha _

Result:
no goals

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
W : Over Y
g : W ⟶ (Over.map f).obj Z
hg : ((overEquiv ((Over.map f).obj Z)).symm S).arrows g
⊢ 𝟙 W.left ≫ ((Over.map f).obj (Over.mk (g.left ≫ Z.hom))).hom = W.hom

Tactic:
simpa using Over.w g

Result:
no goals

Proof state:
case h.mpr
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
W : Over Y
g : W ⟶ (Over.map f).obj Z
⊢ ((overEquiv ((Over.map f).obj Z)).symm S).arrows g → (functorPushforward (Over.map f) ((overEquiv Z).symm S)).arrows g

Tactic:
intro hg

Result:
case h.mpr
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : Over X
S : Sieve Z.left
W : Over Y
g : W ⟶ (Over.map f).obj Z
hg : ((overEquiv ((Over.map f).obj Z)).symm S).arrows g
⊢ (functorPushforward (Over.map f) ((overEquiv Z).symm S)).arrows g