Theorem: AlgebraicGeometry.Scheme.Pullback.openCoverOfBase_J
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : X.OpenCover
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (𝒰✝.map i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : Z.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullback f g).OpenCover
state_after: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : X.OpenCover
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (𝒰✝.map i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : Z.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
⊢ ∀ (i : 𝒰.J),
    pullback.map (pullback.snd f (𝒰.map i)) (pullback.snd g (𝒰.map i)) f g (pullback.fst f (𝒰.map i))
        (pullback.fst g (𝒰.map i)) (𝒰.map i) ⋯ ⋯ =
      (Iso.refl ((fun i => pullback (pullback.snd f (𝒰.map i)) (pullback.snd g (𝒰.map i))) i)).hom ≫
        (openCoverOfBase' 𝒰 f g).map
          (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i)
tactic: apply
    (openCoverOfBase'.{u, u} 𝒰 f g).copy 𝒰.J
      (fun i =>
        pullback (pullback.snd _ _ : pullback f (𝒰.map i) ⟶ _)
          (pullback.snd _ _ : pullback g (𝒰.map i) ⟶ _))
      (fun i =>
        pullback.map _ _ _ _ (pullback.fst _ _) (pullback.fst _ _) (𝒰.map i)
          pullback.condition.symm pullback.condition.symm)
      ((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) fun _ => Iso.refl _
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : X.OpenCover
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (𝒰✝.map i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : Z.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
⊢ ∀ (i : 𝒰.J),
    pullback.map (pullback.snd f (𝒰.map i)) (pullback.snd g (𝒰.map i)) f g (pullback.fst f (𝒰.map i))
        (pullback.fst g (𝒰.map i)) (𝒰.map i) ⋯ ⋯ =
      (Iso.refl ((fun i => pullback (pullback.snd f (𝒰.map i)) (pullback.snd g (𝒰.map i))) i)).hom ≫
        (openCoverOfBase' 𝒰 f g).map
          (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : X.OpenCover
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (𝒰✝.map i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : Z.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map (pullback.snd f (𝒰.map i)) (pullback.snd g (𝒰.map i)) f g (pullback.fst f (𝒰.map i))
      (pullback.fst g (𝒰.map i)) (𝒰.map i) ⋯ ⋯ =
    (Iso.refl ((fun i => pullback (pullback.snd f (𝒰.map i)) (pullback.snd g (𝒰.map i))) i)).hom ≫
      (openCoverOfBase' 𝒰 f g).map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i)
tactic: intro i
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : X.OpenCover
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (𝒰✝.map i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : Z.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map (pullback.snd f (𝒰.map i)) (pullback.snd g (𝒰.map i)) f g (pullback.fst f (𝒰.map i))
      (pullback.fst g (𝒰.map i)) (𝒰.map i) ⋯ ⋯ =
    (Iso.refl ((fun i => pullback (pullback.snd f (𝒰.map i)) (pullback.snd g (𝒰.map i))) i)).hom ≫
      (openCoverOfBase' 𝒰 f g).map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : X.OpenCover
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (𝒰✝.map i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : Z.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map (pullback.snd f (𝒰.map i)) (pullback.snd g (𝒰.map i)) f g (pullback.fst f (𝒰.map i))
      (pullback.fst g (𝒰.map i)) (𝒰.map i) ⋯ ⋯ =
    (pullbackSymmetry
          (pullback.snd f
            (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst))
          (pullback.snd g
            (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst))).hom ≫
      (limit.isoLimitCone
            {
              cone :=
                PullbackCone.mk
                  (pullback.snd
                    (pullback.snd g
                      (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst))
                    (pullback.snd f
                      (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)))
                  (pullback.fst
                      (pullback.snd g
                        (𝒰.map
                          (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst))
                      (pullback.snd f
                        (𝒰.map
                          (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)) ≫
                    pullback.fst g
                      (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst))
                  ⋯,
              isLimit :=
                bigSquareIsPullback
                  (pullback.fst
                    (pullback.snd g
                      (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst))
                    (pullback.snd f
                      (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)))
                  (pullback.fst g
                    (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst))
                  (pullback.snd f
                    (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst))
                  (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)
                  (pullback.snd
                    (pullback.snd g
                      (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst))
                    (pullback.snd f
                      (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)))
                  (pullback.snd g
                    (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst))
                  g ⋯ ⋯
                  (PullbackCone.isLimitOfFlip
                    (pullbackIsPullback g
                      (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)))
                  (PullbackCone.isLimitOfFlip
                    (pullbackIsPullback
                      (pullback.snd g
                        (𝒰.map
                          (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst))
                      (pullback.snd f
                        (𝒰.map
                          (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm)
                              i).fst)))) }).inv ≫
        pullback.map
            (pullback.snd f
                (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst) ≫
              𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)
            g
            (pullback.fst f
                (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst) ≫
              f)
            g
            (𝟙
              (pullback f
                (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)))
            (𝟙 Y) (𝟙 Z) ⋯ ⋯ ≫
          pullback.map
            (pullback.fst f
                (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst) ≫
              f)
            g f g
            (pullback.fst f
              (𝒰.map (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst))
            (𝟙 Y) (𝟙 Z) ⋯ ⋯
tactic: rw [Iso.refl_hom, Category.id_comp, openCoverOfBase'_map]