Theorem: CategoryTheory.Equalizer.Presieve.Arrows.sheaf_condition
File: Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean

tactic: rw [Types.type_equalizer_iff_unique, isSheafFor_arrows_iff]
state_before: C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
⊢ IsSheafFor P (Presieve.ofArrows X π) ↔ Nonempty (IsLimit (Fork.ofι (forkMap P X π) ⋯))
state_after: C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
⊢ (∀ (x : (i : I) → P.obj { unop := X i }), Arrows.Compatible P π x → ∃! t, ∀ (i : I), P.map (π i).op t = x i) ↔
    ∀ (y : FirstObj P X), firstMap P X π y = secondMap P X π y → ∃! x, forkMap P X π x = y

tactic: erw [← Equiv.forall_congr_right (Types.productIso _).toEquiv.symm]
state_before: C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
⊢ (∀ (x : (i : I) → P.obj { unop := X i }), Arrows.Compatible P π x → ∃! t, ∀ (i : I), P.map (π i).op t = x i) ↔
    ∀ (y : FirstObj P X), firstMap P X π y = secondMap P X π y → ∃! x, forkMap P X π x = y
state_after: C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
⊢ (∀ (x : (i : I) → P.obj { unop := X i }), Arrows.Compatible P π x → ∃! t, ∀ (i : I), P.map (π i).op t = x i) ↔
    ∀ (a : (j : I) → P.obj { unop := X j }),
      firstMap P X π ((Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm a) =
          secondMap P X π ((Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm a) →
        ∃! x, forkMap P X π x = (Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm a

tactic: simp_rw [← compatible_iff, ← Iso.toEquiv_fun, Equiv.apply_symm_apply]
state_before: C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
⊢ (∀ (x : (i : I) → P.obj { unop := X i }), Arrows.Compatible P π x → ∃! t, ∀ (i : I), P.map (π i).op t = x i) ↔
    ∀ (a : (j : I) → P.obj { unop := X j }),
      firstMap P X π ((Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm a) =
          secondMap P X π ((Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm a) →
        ∃! x, forkMap P X π x = (Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm a
state_after: C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
⊢ (∀ (x : (i : I) → P.obj { unop := X i }), Arrows.Compatible P π x → ∃! t, ∀ (i : I), P.map (π i).op t = x i) ↔
    ∀ (a : (j : I) → P.obj { unop := X j }),
      Arrows.Compatible P π a → ∃! x, forkMap P X π x = (Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm a

tactic: apply forall₂_congr
state_before: C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
⊢ (∀ (x : (i : I) → P.obj { unop := X i }), Arrows.Compatible P π x → ∃! t, ∀ (i : I), P.map (π i).op t = x i) ↔
    ∀ (a : (j : I) → P.obj { unop := X j }),
      Arrows.Compatible P π a → ∃! x, forkMap P X π x = (Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm a
state_after: case h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
⊢ ∀ (a : (i : I) → P.obj { unop := X i }),
    Arrows.Compatible P π a →
      ((∃! t, ∀ (i : I), P.map (π i).op t = a i) ↔
        ∃! x, forkMap P X π x = (Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm a)

tactic: intro x _
state_before: case h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
⊢ ∀ (a : (i : I) → P.obj { unop := X i }),
    Arrows.Compatible P π a →
      ((∃! t, ∀ (i : I), P.map (π i).op t = a i) ↔
        ∃! x, forkMap P X π x = (Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm a)
state_after: case h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
⊢ (∃! t, ∀ (i : I), P.map (π i).op t = x i) ↔
    ∃! x_1, forkMap P X π x_1 = (Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm x

tactic: apply existsUnique_congr
state_before: case h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
⊢ (∃! t, ∀ (i : I), P.map (π i).op t = x i) ↔
    ∃! x_1, forkMap P X π x_1 = (Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm x
state_after: case h.h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
⊢ ∀ (a : P.obj { unop := B }),
    (∀ (i : I), P.map (π i).op a = x i) ↔
      forkMap P X π a = (Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm x

tactic: intro t
state_before: case h.h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
⊢ ∀ (a : P.obj { unop := B }),
    (∀ (i : I), P.map (π i).op a = x i) ↔
      forkMap P X π a = (Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm x
state_after: case h.h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
⊢ (∀ (i : I), P.map (π i).op t = x i) ↔
    forkMap P X π t = (Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm x

tactic: erw [Equiv.eq_symm_apply]
state_before: case h.h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
⊢ (∀ (i : I), P.map (π i).op t = x i) ↔
    forkMap P X π t = (Types.productIso fun i => P.obj { unop := X i }).toEquiv.symm x
state_after: case h.h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
⊢ (∀ (i : I), P.map (π i).op t = x i) ↔ (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) = x

tactic: constructor
state_before: case h.h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
⊢ (∀ (i : I), P.map (π i).op t = x i) ↔ (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) = x
state_after: case h.h.mp
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
⊢ (∀ (i : I), P.map (π i).op t = x i) → (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) = x

case h.h.mpr
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
⊢ (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) = x → ∀ (i : I), P.map (π i).op t = x i

tactic: intro q
state_before: case h.h.mp
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
⊢ (∀ (i : I), P.map (π i).op t = x i) → (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) = x
state_after: case h.h.mp
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
q : ∀ (i : I), P.map (π i).op t = x i
⊢ (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) = x

tactic: funext i
state_before: case h.h.mp
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
q : ∀ (i : I), P.map (π i).op t = x i
⊢ (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) = x
state_after: case h.h.mp.h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
q : ∀ (i : I), P.map (π i).op t = x i
i : I
⊢ (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) i = x i

tactic: simpa [forkMap] using q i
state_before: case h.h.mp.h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
q : ∀ (i : I), P.map (π i).op t = x i
i : I
⊢ (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) i = x i
state_after: no goals

tactic: intro q i
state_before: case h.h.mpr
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
⊢ (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) = x → ∀ (i : I), P.map (π i).op t = x i
state_after: case h.h.mpr
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
q : (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) = x
i : I
⊢ P.map (π i).op t = x i

tactic: rw [← q]
state_before: case h.h.mpr
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
q : (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) = x
i : I
⊢ P.map (π i).op t = x i
state_after: case h.h.mpr
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
q : (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) = x
i : I
⊢ P.map (π i).op t = (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) i

tactic: simp [forkMap]
state_before: case h.h.mpr
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
b✝ : Arrows.Compatible P π x
t : P.obj { unop := B }
q : (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) = x
i : I
⊢ P.map (π i).op t = (Types.productIso fun i => P.obj { unop := X i }).toEquiv (forkMap P X π t) i
state_after: no goals