Theorem: CategoryTheory.Presieve.isSheafFor_iso
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

tactic: intro h x hx
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
⊢ IsSheafFor P R → IsSheafFor P' R
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
⊢ ∃! t, x.IsAmalgamation t

tactic: let x' := x.compPresheafMap i.inv
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
⊢ ∃! t, x.IsAmalgamation t
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
⊢ ∃! t, x.IsAmalgamation t

tactic: have : x'.Compatible := FamilyOfElements.Compatible.compPresheafMap i.inv hx
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
⊢ ∃! t, x.IsAmalgamation t
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
⊢ ∃! t, x.IsAmalgamation t

tactic: obtain ⟨t, ht1, ht2⟩ := h x' this
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
⊢ ∃! t, x.IsAmalgamation t
state_after: case intro.intro
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
⊢ ∃! t, x.IsAmalgamation t

tactic: use i.hom.app _ t
state_before: case intro.intro
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
⊢ ∃! t, x.IsAmalgamation t
state_after: case h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
⊢ (fun t => x.IsAmalgamation t) (i.hom.app { unop := X } t) ∧
    ∀ (y : P'.obj { unop := X }), (fun t => x.IsAmalgamation t) y → y = i.hom.app { unop := X } t

tactic: fconstructor
state_before: case h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
⊢ (fun t => x.IsAmalgamation t) (i.hom.app { unop := X } t) ∧
    ∀ (y : P'.obj { unop := X }), (fun t => x.IsAmalgamation t) y → y = i.hom.app { unop := X } t
state_after: case h.left
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
⊢ (fun t => x.IsAmalgamation t) (i.hom.app { unop := X } t)

case h.right
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
⊢ ∀ (y : P'.obj { unop := X }), (fun t => x.IsAmalgamation t) y → y = i.hom.app { unop := X } t

tactic: convert FamilyOfElements.IsAmalgamation.compPresheafMap i.hom ht1
state_before: case h.left
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
⊢ (fun t => x.IsAmalgamation t) (i.hom.app { unop := X } t)
state_after: case h.e.h.e'_6.h.h.h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
⊢ x = FamilyOfElements.compPresheafMap i.hom x'

tactic: simp [x']
state_before: case h.e.h.e'_6.h.h.h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
⊢ x = FamilyOfElements.compPresheafMap i.hom x'
state_after: no goals

tactic: intro y hy
state_before: case h.right
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
⊢ ∀ (y : P'.obj { unop := X }), (fun t => x.IsAmalgamation t) y → y = i.hom.app { unop := X } t
state_after: case h.right
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
y : P'.obj { unop := X }
hy : x.IsAmalgamation y
⊢ y = i.hom.app { unop := X } t

tactic: rw [show y = (i.inv.app (op X) ≫ i.hom.app (op X)) y by simp]
state_before: case h.right
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
y : P'.obj { unop := X }
hy : x.IsAmalgamation y
⊢ y = i.hom.app { unop := X } t
state_after: case h.right
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
y : P'.obj { unop := X }
hy : x.IsAmalgamation y
⊢ (i.inv.app { unop := X } ≫ i.hom.app { unop := X }) y = i.hom.app { unop := X } t

tactic: simp [ht2 (i.inv.app _ y) (FamilyOfElements.IsAmalgamation.compPresheafMap i.inv hy)]
state_before: case h.right
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
y : P'.obj { unop := X }
hy : x.IsAmalgamation y
⊢ (i.inv.app { unop := X } ≫ i.hom.app { unop := X }) y = i.hom.app { unop := X } t
state_after: no goals

tactic: simp
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P' : Cᵒᵖ ⥤ Type w
i : P ≅ P'
h : IsSheafFor P R
x : FamilyOfElements P' R
hx : x.Compatible
x' : FamilyOfElements P R := FamilyOfElements.compPresheafMap i.inv x
this : x'.Compatible
t : P.obj { unop := X }
ht1 : x'.IsAmalgamation t
ht2 : ∀ (y : P.obj { unop := X }), (fun t => x'.IsAmalgamation t) y → y = t
y : P'.obj { unop := X }
hy : x.IsAmalgamation y
⊢ y = (i.inv.app { unop := X } ≫ i.hom.app { unop := X }) y
state_after: no goals