Theorem: AlgebraicGeometry.AffineTargetMorphismProperty.IsLocal.stableUnderBaseChange
File: Mathlib/AlgebraicGeometry/Morphisms/Basic.lean

tactic: have h01 := (hP.targetAffineLocally_isLocal.openCover_TFAE
  (pullback.fst : pullback f g ⟶ X)).out 0 1
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : targetAffineLocally P g
⊢ targetAffineLocally P pullback.fst
state_after: P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : targetAffineLocally P g
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
⊢ targetAffineLocally P pullback.fst

tactic: rw [h01]
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : targetAffineLocally P g
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
⊢ targetAffineLocally P pullback.fst
state_after: P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : targetAffineLocally P g
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
⊢ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd

tactic: use S.affineCover.pullbackCover f
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : targetAffineLocally P g
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
⊢ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
state_after: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : targetAffineLocally P g
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
⊢ ∀ (i : (S.affineCover.pullbackCover f).J), targetAffineLocally P pullback.snd

tactic: intro i
state_before: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : targetAffineLocally P g
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
⊢ ∀ (i : (S.affineCover.pullbackCover f).J), targetAffineLocally P pullback.snd
state_after: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : targetAffineLocally P g
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
⊢ targetAffineLocally P pullback.snd

tactic: have h03 := (hP.affine_openCover_TFAE g).out 0 3
state_before: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : targetAffineLocally P g
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
⊢ targetAffineLocally P pullback.snd
state_after: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : targetAffineLocally P g
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
⊢ targetAffineLocally P pullback.snd

tactic: rw [h03] at H
state_before: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : targetAffineLocally P g
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
⊢ targetAffineLocally P pullback.snd
state_after: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
⊢ targetAffineLocally P pullback.snd

tactic: let e : pullback (pullback.fst : pullback f g ⟶ _) ((S.affineCover.pullbackCover f).map i) ≅
    _ := by
  refine pullbackSymmetry _ _ ≪≫ pullbackRightPullbackFstIso f g _ ≪≫ ?_ ≪≫
    (pullbackRightPullbackFstIso (S.affineCover.map i) g
      (pullback.snd : pullback f (S.affineCover.map i) ⟶ _)).symm
  exact asIso
    (pullback.map _ _ _ _ (𝟙 _) (𝟙 _) (𝟙 _) (by simpa using pullback.condition) (by simp))
state_before: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
⊢ targetAffineLocally P pullback.snd
state_after: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
e : pullback pullback.fst ((S.affineCover.pullbackCover f).map i) ≅ pullback pullback.snd pullback.fst :=
  pullbackSymmetry pullback.fst ((S.affineCover.pullbackCover f).map i) ≪≫
    pullbackRightPullbackFstIso f g ((S.affineCover.pullbackCover f).map i) ≪≫
      asIso
          (pullback.map ((S.affineCover.pullbackCover f).map i ≫ f) g (pullback.snd ≫ S.affineCover.map i) g
            (𝟙 ((S.affineCover.pullbackCover f).obj i)) (𝟙 Y) (𝟙 S) ⋯ ⋯) ≪≫
        (pullbackRightPullbackFstIso (S.affineCover.map i) g pullback.snd).symm
⊢ targetAffineLocally P pullback.snd

tactic: have : e.hom ≫ pullback.fst = pullback.snd := by simp [e]
state_before: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
e : pullback pullback.fst ((S.affineCover.pullbackCover f).map i) ≅ pullback pullback.snd pullback.fst :=
  pullbackSymmetry pullback.fst ((S.affineCover.pullbackCover f).map i) ≪≫
    pullbackRightPullbackFstIso f g ((S.affineCover.pullbackCover f).map i) ≪≫
      asIso
          (pullback.map ((S.affineCover.pullbackCover f).map i ≫ f) g (pullback.snd ≫ S.affineCover.map i) g
            (𝟙 ((S.affineCover.pullbackCover f).obj i)) (𝟙 Y) (𝟙 S) ⋯ ⋯) ≪≫
        (pullbackRightPullbackFstIso (S.affineCover.map i) g pullback.snd).symm
⊢ targetAffineLocally P pullback.snd
state_after: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
e : pullback pullback.fst ((S.affineCover.pullbackCover f).map i) ≅ pullback pullback.snd pullback.fst :=
  pullbackSymmetry pullback.fst ((S.affineCover.pullbackCover f).map i) ≪≫
    pullbackRightPullbackFstIso f g ((S.affineCover.pullbackCover f).map i) ≪≫
      asIso
          (pullback.map ((S.affineCover.pullbackCover f).map i ≫ f) g (pullback.snd ≫ S.affineCover.map i) g
            (𝟙 ((S.affineCover.pullbackCover f).obj i)) (𝟙 Y) (𝟙 S) ⋯ ⋯) ≪≫
        (pullbackRightPullbackFstIso (S.affineCover.map i) g pullback.snd).symm
this : e.hom ≫ pullback.fst = pullback.snd
⊢ targetAffineLocally P pullback.snd

tactic: rw [← this, (targetAffineLocally_respectsIso hP.1).cancel_left_isIso]
state_before: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
e : pullback pullback.fst ((S.affineCover.pullbackCover f).map i) ≅ pullback pullback.snd pullback.fst :=
  pullbackSymmetry pullback.fst ((S.affineCover.pullbackCover f).map i) ≪≫
    pullbackRightPullbackFstIso f g ((S.affineCover.pullbackCover f).map i) ≪≫
      asIso
          (pullback.map ((S.affineCover.pullbackCover f).map i ≫ f) g (pullback.snd ≫ S.affineCover.map i) g
            (𝟙 ((S.affineCover.pullbackCover f).obj i)) (𝟙 Y) (𝟙 S) ⋯ ⋯) ≪≫
        (pullbackRightPullbackFstIso (S.affineCover.map i) g pullback.snd).symm
this : e.hom ≫ pullback.fst = pullback.snd
⊢ targetAffineLocally P pullback.snd
state_after: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
e : pullback pullback.fst ((S.affineCover.pullbackCover f).map i) ≅ pullback pullback.snd pullback.fst :=
  pullbackSymmetry pullback.fst ((S.affineCover.pullbackCover f).map i) ≪≫
    pullbackRightPullbackFstIso f g ((S.affineCover.pullbackCover f).map i) ≪≫
      asIso
          (pullback.map ((S.affineCover.pullbackCover f).map i ≫ f) g (pullback.snd ≫ S.affineCover.map i) g
            (𝟙 ((S.affineCover.pullbackCover f).obj i)) (𝟙 Y) (𝟙 S) ⋯ ⋯) ≪≫
        (pullbackRightPullbackFstIso (S.affineCover.map i) g pullback.snd).symm
this : e.hom ≫ pullback.fst = pullback.snd
⊢ targetAffineLocally P pullback.fst

tactic: apply hP.targetAffineLocally_pullback_fst_of_right_of_stableUnderBaseChange hP'
state_before: case h
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
e : pullback pullback.fst ((S.affineCover.pullbackCover f).map i) ≅ pullback pullback.snd pullback.fst :=
  pullbackSymmetry pullback.fst ((S.affineCover.pullbackCover f).map i) ≪≫
    pullbackRightPullbackFstIso f g ((S.affineCover.pullbackCover f).map i) ≪≫
      asIso
          (pullback.map ((S.affineCover.pullbackCover f).map i ≫ f) g (pullback.snd ≫ S.affineCover.map i) g
            (𝟙 ((S.affineCover.pullbackCover f).obj i)) (𝟙 Y) (𝟙 S) ⋯ ⋯) ≪≫
        (pullbackRightPullbackFstIso (S.affineCover.map i) g pullback.snd).symm
this : e.hom ≫ pullback.fst = pullback.snd
⊢ targetAffineLocally P pullback.fst
state_after: case h.H
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
e : pullback pullback.fst ((S.affineCover.pullbackCover f).map i) ≅ pullback pullback.snd pullback.fst :=
  pullbackSymmetry pullback.fst ((S.affineCover.pullbackCover f).map i) ≪≫
    pullbackRightPullbackFstIso f g ((S.affineCover.pullbackCover f).map i) ≪≫
      asIso
          (pullback.map ((S.affineCover.pullbackCover f).map i ≫ f) g (pullback.snd ≫ S.affineCover.map i) g
            (𝟙 ((S.affineCover.pullbackCover f).obj i)) (𝟙 Y) (𝟙 S) ⋯ ⋯) ≪≫
        (pullbackRightPullbackFstIso (S.affineCover.map i) g pullback.snd).symm
this : e.hom ≫ pullback.fst = pullback.snd
⊢ P pullback.fst

tactic: rw [← pullbackSymmetry_hom_comp_snd, affine_cancel_left_isIso hP.1]
state_before: case h.H
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
e : pullback pullback.fst ((S.affineCover.pullbackCover f).map i) ≅ pullback pullback.snd pullback.fst :=
  pullbackSymmetry pullback.fst ((S.affineCover.pullbackCover f).map i) ≪≫
    pullbackRightPullbackFstIso f g ((S.affineCover.pullbackCover f).map i) ≪≫
      asIso
          (pullback.map ((S.affineCover.pullbackCover f).map i ≫ f) g (pullback.snd ≫ S.affineCover.map i) g
            (𝟙 ((S.affineCover.pullbackCover f).obj i)) (𝟙 Y) (𝟙 S) ⋯ ⋯) ≪≫
        (pullbackRightPullbackFstIso (S.affineCover.map i) g pullback.snd).symm
this : e.hom ≫ pullback.fst = pullback.snd
⊢ P pullback.fst
state_after: case h.H
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
e : pullback pullback.fst ((S.affineCover.pullbackCover f).map i) ≅ pullback pullback.snd pullback.fst :=
  pullbackSymmetry pullback.fst ((S.affineCover.pullbackCover f).map i) ≪≫
    pullbackRightPullbackFstIso f g ((S.affineCover.pullbackCover f).map i) ≪≫
      asIso
          (pullback.map ((S.affineCover.pullbackCover f).map i ≫ f) g (pullback.snd ≫ S.affineCover.map i) g
            (𝟙 ((S.affineCover.pullbackCover f).obj i)) (𝟙 Y) (𝟙 S) ⋯ ⋯) ≪≫
        (pullbackRightPullbackFstIso (S.affineCover.map i) g pullback.snd).symm
this : e.hom ≫ pullback.fst = pullback.snd
⊢ P pullback.snd

tactic: apply H
state_before: case h.H
P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
e : pullback pullback.fst ((S.affineCover.pullbackCover f).map i) ≅ pullback pullback.snd pullback.fst :=
  pullbackSymmetry pullback.fst ((S.affineCover.pullbackCover f).map i) ≪≫
    pullbackRightPullbackFstIso f g ((S.affineCover.pullbackCover f).map i) ≪≫
      asIso
          (pullback.map ((S.affineCover.pullbackCover f).map i ≫ f) g (pullback.snd ≫ S.affineCover.map i) g
            (𝟙 ((S.affineCover.pullbackCover f).obj i)) (𝟙 Y) (𝟙 S) ⋯ ⋯) ≪≫
        (pullbackRightPullbackFstIso (S.affineCover.map i) g pullback.snd).symm
this : e.hom ≫ pullback.fst = pullback.snd
⊢ P pullback.snd
state_after: no goals

tactic: refine pullbackSymmetry _ _ ≪≫ pullbackRightPullbackFstIso f g _ ≪≫ ?_ ≪≫
  (pullbackRightPullbackFstIso (S.affineCover.map i) g
    (pullback.snd : pullback f (S.affineCover.map i) ⟶ _)).symm
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
⊢ pullback pullback.fst ((S.affineCover.pullbackCover f).map i) ≅ ?m.82105
state_after: P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
⊢ pullback ((S.affineCover.pullbackCover f).map i ≫ f) g ≅ pullback (pullback.snd ≫ S.affineCover.map i) g

tactic: exact asIso
  (pullback.map _ _ _ _ (𝟙 _) (𝟙 _) (𝟙 _) (by simpa using pullback.condition) (by simp))
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
⊢ pullback ((S.affineCover.pullbackCover f).map i ≫ f) g ≅ pullback (pullback.snd ≫ S.affineCover.map i) g
state_after: no goals

tactic: simpa using pullback.condition
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
⊢ ((S.affineCover.pullbackCover f).map i ≫ f) ≫ 𝟙 S =
    𝟙 ((S.affineCover.pullbackCover f).obj i) ≫ pullback.snd ≫ S.affineCover.map i
state_after: no goals

tactic: simp
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
⊢ g ≫ 𝟙 S = 𝟙 Y ≫ g
state_after: no goals

tactic: simp [e]
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
hP' : P.StableUnderBaseChange
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
H : ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
h01 : targetAffineLocally P pullback.fst ↔ ∃ 𝒰, ∀ (i : 𝒰.J), targetAffineLocally P pullback.snd
i : (S.affineCover.pullbackCover f).J
h03 :
  targetAffineLocally P g ↔
    ∀ {U : Scheme} (g_1 : U ⟶ S) [inst : IsAffine U] [inst_1 : IsOpenImmersion g_1], P pullback.snd
e : pullback pullback.fst ((S.affineCover.pullbackCover f).map i) ≅ pullback pullback.snd pullback.fst :=
  pullbackSymmetry pullback.fst ((S.affineCover.pullbackCover f).map i) ≪≫
    pullbackRightPullbackFstIso f g ((S.affineCover.pullbackCover f).map i) ≪≫
      asIso
          (pullback.map ((S.affineCover.pullbackCover f).map i ≫ f) g (pullback.snd ≫ S.affineCover.map i) g
            (𝟙 ((S.affineCover.pullbackCover f).obj i)) (𝟙 Y) (𝟙 S) ⋯ ⋯) ≪≫
        (pullbackRightPullbackFstIso (S.affineCover.map i) g pullback.snd).symm
⊢ e.hom ≫ pullback.fst = pullback.snd
state_after: no goals