Theorem: AlgebraicGeometry.RingedSpace.isUnit_of_isUnit_germ
File: Mathlib/Geometry/RingedSpace/Basic.lean

tactic: choose V iVU m h_unit using fun x : U => X.isUnit_res_of_isUnit_germ U f x (h x)
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
⊢ IsUnit f
state_after: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
⊢ IsUnit f

tactic: have hcover : U ≤ iSup V := by
  intro x hxU
  erw [Opens.mem_iSup]
  exact ⟨⟨x, hxU⟩, m ⟨x, hxU⟩⟩
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
⊢ IsUnit f
state_after: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
⊢ IsUnit f

tactic: choose g hg using fun x : U => IsUnit.exists_right_inv (h_unit x)
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
⊢ IsUnit f
state_after: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
⊢ IsUnit f

tactic: have ic : IsCompatible (sheaf X).val V g := by
  intro x y
  apply section_ext X.sheaf (V x ⊓ V y)
  rintro ⟨z, hzVx, hzVy⟩
  erw [germ_res_apply, germ_res_apply]
  apply (IsUnit.mul_right_inj (h ⟨z, (iVU x).le hzVx⟩)).mp
  rw [← show X.presheaf.germ ⟨z, hzVx⟩ (X.presheaf.map (iVU x).op f) =
    X.presheaf.germ ⟨z, ((iVU x) ⟨z, hzVx⟩).2⟩ f from
    X.presheaf.germ_res_apply (iVU x) ⟨z, hzVx⟩ f]
  change X.presheaf.germ ⟨z, hzVx⟩ _ * (X.presheaf.germ ⟨z, hzVx⟩ _) =
    X.presheaf.germ ⟨z, hzVx⟩ _ * X.presheaf.germ ⟨z, hzVy⟩ (g y)
  rw [← RingHom.map_mul,
    congr_arg (X.presheaf.germ (⟨z, hzVx⟩ : V x)) (hg x),
    show X.presheaf.germ ⟨z, hzVx⟩ (X.presheaf.map (iVU x).op f) =
      X.presheaf.germ ⟨z, ((iVU x) ⟨z, hzVx⟩).2⟩ f from X.presheaf.germ_res_apply _ _ f,
    ← show X.presheaf.germ ⟨z, hzVy⟩ (X.presheaf.map (iVU y).op f) =
        X.presheaf.germ ⟨z, ((iVU x) ⟨z, hzVx⟩).2⟩ f from
        X.presheaf.germ_res_apply (iVU y) ⟨z, hzVy⟩ f,
    ← RingHom.map_mul,
    congr_arg (X.presheaf.germ (⟨z, hzVy⟩ : V y)) (hg y), RingHom.map_one, RingHom.map_one]
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
⊢ IsUnit f
state_after: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
ic : IsCompatible (sheaf X).val V g
⊢ IsUnit f

tactic: obtain ⟨gl, gl_spec, -⟩ := X.sheaf.existsUnique_gluing' V U iVU hcover g ic
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
ic : IsCompatible (sheaf X).val V g
⊢ IsUnit f
state_after: case intro.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
ic : IsCompatible (sheaf X).val V g
gl : (CategoryTheory.forget CommRingCat).obj ((sheaf X).val.obj { unop := U })
gl_spec : ∀ (i : ↥U), ((sheaf X).val.map (iVU i).op) gl = g i
⊢ IsUnit f

tactic: apply isUnit_of_mul_eq_one f gl
state_before: case intro.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
ic : IsCompatible (sheaf X).val V g
gl : (CategoryTheory.forget CommRingCat).obj ((sheaf X).val.obj { unop := U })
gl_spec : ∀ (i : ↥U), ((sheaf X).val.map (iVU i).op) gl = g i
⊢ IsUnit f
state_after: case intro.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
ic : IsCompatible (sheaf X).val V g
gl : (CategoryTheory.forget CommRingCat).obj ((sheaf X).val.obj { unop := U })
gl_spec : ∀ (i : ↥U), ((sheaf X).val.map (iVU i).op) gl = g i
⊢ f * gl = 1

tactic: apply X.sheaf.eq_of_locally_eq' V U iVU hcover
state_before: case intro.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
ic : IsCompatible (sheaf X).val V g
gl : (CategoryTheory.forget CommRingCat).obj ((sheaf X).val.obj { unop := U })
gl_spec : ∀ (i : ↥U), ((sheaf X).val.map (iVU i).op) gl = g i
⊢ f * gl = 1
state_after: case intro.intro.h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
ic : IsCompatible (sheaf X).val V g
gl : (CategoryTheory.forget CommRingCat).obj ((sheaf X).val.obj { unop := U })
gl_spec : ∀ (i : ↥U), ((sheaf X).val.map (iVU i).op) gl = g i
⊢ ∀ (i : ↥U), ((sheaf X).val.map (iVU i).op) (f * gl) = ((sheaf X).val.map (iVU i).op) 1

tactic: intro i
state_before: case intro.intro.h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
ic : IsCompatible (sheaf X).val V g
gl : (CategoryTheory.forget CommRingCat).obj ((sheaf X).val.obj { unop := U })
gl_spec : ∀ (i : ↥U), ((sheaf X).val.map (iVU i).op) gl = g i
⊢ ∀ (i : ↥U), ((sheaf X).val.map (iVU i).op) (f * gl) = ((sheaf X).val.map (iVU i).op) 1
state_after: case intro.intro.h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
ic : IsCompatible (sheaf X).val V g
gl : (CategoryTheory.forget CommRingCat).obj ((sheaf X).val.obj { unop := U })
gl_spec : ∀ (i : ↥U), ((sheaf X).val.map (iVU i).op) gl = g i
i : ↥U
⊢ ((sheaf X).val.map (iVU i).op) (f * gl) = ((sheaf X).val.map (iVU i).op) 1

tactic: rw [RingHom.map_one, RingHom.map_mul, gl_spec]
state_before: case intro.intro.h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
ic : IsCompatible (sheaf X).val V g
gl : (CategoryTheory.forget CommRingCat).obj ((sheaf X).val.obj { unop := U })
gl_spec : ∀ (i : ↥U), ((sheaf X).val.map (iVU i).op) gl = g i
i : ↥U
⊢ ((sheaf X).val.map (iVU i).op) (f * gl) = ((sheaf X).val.map (iVU i).op) 1
state_after: case intro.intro.h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
ic : IsCompatible (sheaf X).val V g
gl : (CategoryTheory.forget CommRingCat).obj ((sheaf X).val.obj { unop := U })
gl_spec : ∀ (i : ↥U), ((sheaf X).val.map (iVU i).op) gl = g i
i : ↥U
⊢ ((sheaf X).val.map (iVU i).op) f * g i = 1

tactic: exact hg i
state_before: case intro.intro.h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
ic : IsCompatible (sheaf X).val V g
gl : (CategoryTheory.forget CommRingCat).obj ((sheaf X).val.obj { unop := U })
gl_spec : ∀ (i : ↥U), ((sheaf X).val.map (iVU i).op) gl = g i
i : ↥U
⊢ ((sheaf X).val.map (iVU i).op) f * g i = 1
state_after: no goals

tactic: intro x hxU
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
⊢ U ≤ iSup V
state_after: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
x : ↑↑X.toPresheafedSpace
hxU : x ∈ ↑U
⊢ x ∈ ↑(iSup V)

tactic: erw [Opens.mem_iSup]
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
x : ↑↑X.toPresheafedSpace
hxU : x ∈ ↑U
⊢ x ∈ ↑(iSup V)
state_after: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
x : ↑↑X.toPresheafedSpace
hxU : x ∈ ↑U
⊢ ∃ i, x ∈ V i

tactic: exact ⟨⟨x, hxU⟩, m ⟨x, hxU⟩⟩
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
x : ↑↑X.toPresheafedSpace
hxU : x ∈ ↑U
⊢ ∃ i, x ∈ V i
state_after: no goals

tactic: intro x y
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
⊢ IsCompatible (sheaf X).val V g
state_after: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
⊢ ((sheaf X).val.map ((V x).infLELeft (V y)).op) (g x) = ((sheaf X).val.map ((V x).infLERight (V y)).op) (g y)

tactic: apply section_ext X.sheaf (V x ⊓ V y)
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
⊢ ((sheaf X).val.map ((V x).infLELeft (V y)).op) (g x) = ((sheaf X).val.map ((V x).infLERight (V y)).op) (g y)
state_after: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
⊢ ∀ (x_1 : ↥(V x ⊓ V y)),
    ((sheaf X).presheaf.germ x_1) (((sheaf X).val.map ((V x).infLELeft (V y)).op) (g x)) =
      ((sheaf X).presheaf.germ x_1) (((sheaf X).val.map ((V x).infLERight (V y)).op) (g y))

tactic: rintro ⟨z, hzVx, hzVy⟩
state_before: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
⊢ ∀ (x_1 : ↥(V x ⊓ V y)),
    ((sheaf X).presheaf.germ x_1) (((sheaf X).val.map ((V x).infLELeft (V y)).op) (g x)) =
      ((sheaf X).presheaf.germ x_1) (((sheaf X).val.map ((V x).infLERight (V y)).op) (g y))
state_after: case h.mk.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
z : ↑↑X.toPresheafedSpace
hzVx : z ∈ ↑(V x)
hzVy : z ∈ ↑(V y)
⊢ ((sheaf X).presheaf.germ ⟨z, ⋯⟩) (((sheaf X).val.map ((V x).infLELeft (V y)).op) (g x)) =
    ((sheaf X).presheaf.germ ⟨z, ⋯⟩) (((sheaf X).val.map ((V x).infLERight (V y)).op) (g y))

tactic: erw [germ_res_apply, germ_res_apply]
state_before: case h.mk.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
z : ↑↑X.toPresheafedSpace
hzVx : z ∈ ↑(V x)
hzVy : z ∈ ↑(V y)
⊢ ((sheaf X).presheaf.germ ⟨z, ⋯⟩) (((sheaf X).val.map ((V x).infLELeft (V y)).op) (g x)) =
    ((sheaf X).presheaf.germ ⟨z, ⋯⟩) (((sheaf X).val.map ((V x).infLERight (V y)).op) (g y))
state_after: case h.mk.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
z : ↑↑X.toPresheafedSpace
hzVx : z ∈ ↑(V x)
hzVy : z ∈ ↑(V y)
⊢ ((sheaf X).presheaf.germ ((fun x_1 => ⟨↑x_1, ⋯⟩) ⟨z, ⋯⟩)) (g x) =
    ((sheaf X).presheaf.germ ((fun x_1 => ⟨↑x_1, ⋯⟩) ⟨z, ⋯⟩)) (g y)

tactic: apply (IsUnit.mul_right_inj (h ⟨z, (iVU x).le hzVx⟩)).mp
state_before: case h.mk.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
z : ↑↑X.toPresheafedSpace
hzVx : z ∈ ↑(V x)
hzVy : z ∈ ↑(V y)
⊢ ((sheaf X).presheaf.germ ((fun x_1 => ⟨↑x_1, ⋯⟩) ⟨z, ⋯⟩)) (g x) =
    ((sheaf X).presheaf.germ ((fun x_1 => ⟨↑x_1, ⋯⟩) ⟨z, ⋯⟩)) (g y)
state_after: case h.mk.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
z : ↑↑X.toPresheafedSpace
hzVx : z ∈ ↑(V x)
hzVy : z ∈ ↑(V y)
⊢ (X.presheaf.germ ⟨z, ⋯⟩) f * ((sheaf X).presheaf.germ ((fun x_1 => ⟨↑x_1, ⋯⟩) ⟨z, ⋯⟩)) (g x) =
    (X.presheaf.germ ⟨z, ⋯⟩) f * ((sheaf X).presheaf.germ ((fun x_1 => ⟨↑x_1, ⋯⟩) ⟨z, ⋯⟩)) (g y)

tactic: rw [← show X.presheaf.germ ⟨z, hzVx⟩ (X.presheaf.map (iVU x).op f) =
  X.presheaf.germ ⟨z, ((iVU x) ⟨z, hzVx⟩).2⟩ f from
  X.presheaf.germ_res_apply (iVU x) ⟨z, hzVx⟩ f]
state_before: case h.mk.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
z : ↑↑X.toPresheafedSpace
hzVx : z ∈ ↑(V x)
hzVy : z ∈ ↑(V y)
⊢ (X.presheaf.germ ⟨z, ⋯⟩) f * ((sheaf X).presheaf.germ ((fun x_1 => ⟨↑x_1, ⋯⟩) ⟨z, ⋯⟩)) (g x) =
    (X.presheaf.germ ⟨z, ⋯⟩) f * ((sheaf X).presheaf.germ ((fun x_1 => ⟨↑x_1, ⋯⟩) ⟨z, ⋯⟩)) (g y)
state_after: case h.mk.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
z : ↑↑X.toPresheafedSpace
hzVx : z ∈ ↑(V x)
hzVy : z ∈ ↑(V y)
⊢ (X.presheaf.germ ⟨z, hzVx⟩) ((X.presheaf.map (iVU x).op) f) *
      ((sheaf X).presheaf.germ ((fun x_1 => ⟨↑x_1, ⋯⟩) ⟨z, ⋯⟩)) (g x) =
    (X.presheaf.germ ⟨z, hzVx⟩) ((X.presheaf.map (iVU x).op) f) *
      ((sheaf X).presheaf.germ ((fun x_1 => ⟨↑x_1, ⋯⟩) ⟨z, ⋯⟩)) (g y)

tactic: change X.presheaf.germ ⟨z, hzVx⟩ _ * (X.presheaf.germ ⟨z, hzVx⟩ _) =
  X.presheaf.germ ⟨z, hzVx⟩ _ * X.presheaf.germ ⟨z, hzVy⟩ (g y)
state_before: case h.mk.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
z : ↑↑X.toPresheafedSpace
hzVx : z ∈ ↑(V x)
hzVy : z ∈ ↑(V y)
⊢ (X.presheaf.germ ⟨z, hzVx⟩) ((X.presheaf.map (iVU x).op) f) *
      ((sheaf X).presheaf.germ ((fun x_1 => ⟨↑x_1, ⋯⟩) ⟨z, ⋯⟩)) (g x) =
    (X.presheaf.germ ⟨z, hzVx⟩) ((X.presheaf.map (iVU x).op) f) *
      ((sheaf X).presheaf.germ ((fun x_1 => ⟨↑x_1, ⋯⟩) ⟨z, ⋯⟩)) (g y)
state_after: case h.mk.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
z : ↑↑X.toPresheafedSpace
hzVx : z ∈ ↑(V x)
hzVy : z ∈ ↑(V y)
⊢ (X.presheaf.germ ⟨z, hzVx⟩) ((X.presheaf.map (iVU x).op) f) * (X.presheaf.germ ⟨z, hzVx⟩) (g x) =
    (X.presheaf.germ ⟨z, hzVx⟩) ((X.presheaf.map (iVU x).op) f) * (X.presheaf.germ ⟨z, hzVy⟩) (g y)

tactic: rw [← RingHom.map_mul,
  congr_arg (X.presheaf.germ (⟨z, hzVx⟩ : V x)) (hg x),
  show X.presheaf.germ ⟨z, hzVx⟩ (X.presheaf.map (iVU x).op f) =
    X.presheaf.germ ⟨z, ((iVU x) ⟨z, hzVx⟩).2⟩ f from X.presheaf.germ_res_apply _ _ f,
  ← show X.presheaf.germ ⟨z, hzVy⟩ (X.presheaf.map (iVU y).op f) =
      X.presheaf.germ ⟨z, ((iVU x) ⟨z, hzVx⟩).2⟩ f from
      X.presheaf.germ_res_apply (iVU y) ⟨z, hzVy⟩ f,
  ← RingHom.map_mul,
  congr_arg (X.presheaf.germ (⟨z, hzVy⟩ : V y)) (hg y), RingHom.map_one, RingHom.map_one]
state_before: case h.mk.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
h : ∀ (x : ↥U), IsUnit ((X.presheaf.germ x) f)
V : ↥U → Opens ↑↑X.toPresheafedSpace
iVU : (x : ↥U) → V x ⟶ U
m : ∀ (x : ↥U), ↑x ∈ V x
h_unit : ∀ (x : ↥U), IsUnit ((X.presheaf.map (iVU x).op) f)
hcover : U ≤ iSup V
g : (x : ↥U) → ↑(X.presheaf.obj { unop := V x })
hg : ∀ (x : ↥U), (X.presheaf.map (iVU x).op) f * g x = 1
x y : ↥U
z : ↑↑X.toPresheafedSpace
hzVx : z ∈ ↑(V x)
hzVy : z ∈ ↑(V y)
⊢ (X.presheaf.germ ⟨z, hzVx⟩) ((X.presheaf.map (iVU x).op) f) * (X.presheaf.germ ⟨z, hzVx⟩) (g x) =
    (X.presheaf.germ ⟨z, hzVx⟩) ((X.presheaf.map (iVU x).op) f) * (X.presheaf.germ ⟨z, hzVy⟩) (g y)
state_after: no goals