Theorem: TopCat.Sheaf.objSupIsoProdEqLocus_inv_eq_iff
File: Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean

tactic: subst h₁ h₂
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W UW VW : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
h₁ : UW = U ⊓ W
h₂ : VW = V ⊓ W
⊢ (F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x) = y ↔
    (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y ∧
      (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
⊢ (F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x) = y ↔
    (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y ∧
      (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y

tactic: constructor
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
⊢ (F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x) = y ↔
    (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y ∧
      (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
state_after: case mp
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
⊢ (F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x) = y →
    (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y ∧
      (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y

case mpr
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
⊢ (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y ∧
      (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y →
    (F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x) = y

tactic: rintro rfl
state_before: case mp
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
⊢ (F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x) = y →
    (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y ∧
      (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
state_after: case mp
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
⊢ (F.val.map (homOfLE ⋯).op) (↑x).1 =
      (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x)) ∧
    (F.val.map (homOfLE ⋯).op) (↑x).2 =
      (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x))

tactic: rw [← TopCat.Sheaf.objSupIsoProdEqLocus_inv_fst, ← TopCat.Sheaf.objSupIsoProdEqLocus_inv_snd]
state_before: case mp
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
⊢ (F.val.map (homOfLE ⋯).op) (↑x).1 =
      (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x)) ∧
    (F.val.map (homOfLE ⋯).op) (↑x).2 =
      (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x))
state_after: case mp
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
⊢ (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)) =
      (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x)) ∧
    (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)) =
      (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x))

tactic: repeat rw [← comp_apply]
state_before: case mp
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
⊢ (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)) =
      (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x)) ∧
    (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)) =
      (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x))
state_after: case mp
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
⊢ (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
      (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) ∧
    (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
      (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)

tactic: simp only [← Functor.map_comp, ← op_comp, Category.assoc, homOfLE_comp, and_self]
state_before: case mp
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
⊢ (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
      (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) ∧
    (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
      (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)
state_after: no goals

tactic: rw [← comp_apply]
state_before: case mp
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
⊢ (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
      (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) ∧
    (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
      (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x))
state_after: case mp
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
⊢ (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
      (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) ∧
    (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
      (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)

tactic: rintro ⟨e₁, e₂⟩
state_before: case mpr
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
⊢ (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y ∧
      (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y →
    (F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x) = y
state_after: case mpr.intro
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x) = y

tactic: refine F.eq_of_locally_eq₂
  (homOfLE (inf_le_right : U ⊓ W ≤ W)) (homOfLE (inf_le_right : V ⊓ W ≤ W)) ?_ _ _ ?_ ?_
state_before: case mpr.intro
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x) = y
state_after: case mpr.intro.refine_1
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ W ≤ U ⊓ W ⊔ V ⊓ W

case mpr.intro.refine_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x)) =
    (F.val.map (homOfLE ⋯).op) y

case mpr.intro.refine_3
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x)) =
    (F.val.map (homOfLE ⋯).op) y

tactic: rw [← inf_sup_right]
state_before: case mpr.intro.refine_1
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ W ≤ U ⊓ W ⊔ V ⊓ W
state_after: case mpr.intro.refine_1
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ W ≤ (U ⊔ V) ⊓ W

tactic: exact le_inf e le_rfl
state_before: case mpr.intro.refine_1
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ W ≤ (U ⊔ V) ⊓ W
state_after: no goals

tactic: rw [← e₁, ← TopCat.Sheaf.objSupIsoProdEqLocus_inv_fst]
state_before: case mpr.intro.refine_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x)) =
    (F.val.map (homOfLE ⋯).op) y
state_after: case mpr.intro.refine_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x)) =
    (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x))

tactic: repeat rw [← comp_apply]
state_before: case mpr.intro.refine_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x)) =
    (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x))
state_after: case mpr.intro.refine_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
    (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)

tactic: simp only [← Functor.map_comp, ← op_comp, Category.assoc, homOfLE_comp]
state_before: case mpr.intro.refine_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
    (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)
state_after: no goals

tactic: rw [← comp_apply]
state_before: case mpr.intro.refine_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
    (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x))
state_after: case mpr.intro.refine_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
    (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)

tactic: rw [← e₂, ← TopCat.Sheaf.objSupIsoProdEqLocus_inv_snd]
state_before: case mpr.intro.refine_3
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x)) =
    (F.val.map (homOfLE ⋯).op) y
state_after: case mpr.intro.refine_3
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x)) =
    (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x))

tactic: repeat rw [← comp_apply]
state_before: case mpr.intro.refine_3
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE e).op) ((F.objSupIsoProdEqLocus U V).inv x)) =
    (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x))
state_after: case mpr.intro.refine_3
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
    (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)

tactic: simp only [← Functor.map_comp, ← op_comp, Category.assoc, homOfLE_comp]
state_before: case mpr.intro.refine_3
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
    (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)
state_after: no goals

tactic: rw [← comp_apply]
state_before: case mpr.intro.refine_3
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
    (F.val.map (homOfLE ⋯).op) ((F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x))
state_after: case mpr.intro.refine_3
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
  ↥((RingHom.comp (F.val.map (homOfLE ⋯).op)
          (RingHom.fst ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))).eqLocus
      (RingHom.comp (F.val.map (homOfLE ⋯).op) (RingHom.snd ↑(F.val.obj { unop := U }) ↑(F.val.obj { unop := V }))))
y : ↑(F.val.obj { unop := W })
e₁ : (F.val.map (homOfLE ⋯).op) (↑x).1 = (F.val.map (homOfLE ⋯).op) y
e₂ : (F.val.map (homOfLE ⋯).op) (↑x).2 = (F.val.map (homOfLE ⋯).op) y
⊢ (F.val.map (homOfLE e).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x) =
    (F.val.map (homOfLE ⋯).op ≫ F.val.map (homOfLE ⋯).op) ((F.objSupIsoProdEqLocus U V).inv x)