Theorem: AlgebraicGeometry.IsAffineOpen.SpecΓIdentity_hom_app_fromSpec
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

tactic: have : IsAffine _ := hU
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ (Scheme.ΓSpecIso Γ(X, U)).hom ≫ Scheme.Hom.app hU.fromSpec U = (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
this : IsAffine (X.restrict ⋯)
⊢ (Scheme.ΓSpecIso Γ(X, U)).hom ≫ Scheme.Hom.app hU.fromSpec U = (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op

tactic: delta IsAffineOpen.fromSpec Scheme.isoSpec
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
this : IsAffine (X.restrict ⋯)
⊢ (Scheme.ΓSpecIso Γ(X, U)).hom ≫ Scheme.Hom.app hU.fromSpec U = (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
this : IsAffine (X.restrict ⋯)
⊢ (Scheme.ΓSpecIso Γ(X, U)).hom ≫
      Scheme.Hom.app
        (Spec.map (X.presheaf.map (eqToHom ⋯).op) ≫
          (asIso (ΓSpec.adjunction.unit.app (X.restrict ⋯))).inv ≫ Scheme.ιOpens U)
        U =
    (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op

tactic: rw [Scheme.comp_app, Scheme.comp_app, ΓSpecIso_obj_hom,
  Scheme.ofRestrict_app_self]
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
this : IsAffine (X.restrict ⋯)
⊢ (Scheme.ΓSpecIso Γ(X, U)).hom ≫
      Scheme.Hom.app
        (Spec.map (X.presheaf.map (eqToHom ⋯).op) ≫
          (asIso (ΓSpec.adjunction.unit.app (X.restrict ⋯))).inv ≫ Scheme.ιOpens U)
        U =
    (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
this : IsAffine (X.restrict ⋯)
⊢ (Scheme.Γ.map (Spec.map (X.presheaf.map (eqToHom ⋯).op)).op ≫
        Scheme.Hom.app (ΓSpec.adjunction.unit.app (X ∣_ᵤ U)) ⊤ ≫ X.presheaf.map (eqToHom ⋯).op) ≫
      (X.presheaf.map (eqToHom ⋯).op ≫
          Scheme.Hom.app (asIso (ΓSpec.adjunction.unit.app (X.restrict ⋯))).inv (Scheme.ιOpens U ⁻¹ᵁ U)) ≫
        Scheme.Hom.app (Spec.map (X.presheaf.map (eqToHom ⋯).op))
          (((asIso (ΓSpec.adjunction.unit.app (X.restrict ⋯))).inv ≫ Scheme.ιOpens U) ⁻¹ᵁ U) =
    (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op

tactic: simp only [Category.assoc]
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
this : IsAffine (X.restrict ⋯)
⊢ (Scheme.Γ.map (Spec.map (X.presheaf.map (eqToHom ⋯).op)).op ≫
        Scheme.Hom.app (ΓSpec.adjunction.unit.app (X ∣_ᵤ U)) ⊤ ≫ X.presheaf.map (eqToHom ⋯).op) ≫
      (X.presheaf.map (eqToHom ⋯).op ≫
          Scheme.Hom.app (asIso (ΓSpec.adjunction.unit.app (X.restrict ⋯))).inv (Scheme.ιOpens U ⁻¹ᵁ U)) ≫
        Scheme.Hom.app (Spec.map (X.presheaf.map (eqToHom ⋯).op))
          (((asIso (ΓSpec.adjunction.unit.app (X.restrict ⋯))).inv ≫ Scheme.ιOpens U) ⁻¹ᵁ U) =
    (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
this : IsAffine (X.restrict ⋯)
⊢ Scheme.Γ.map (Spec.map (X.presheaf.map (eqToHom ⋯).op)).op ≫
      Scheme.Hom.app (ΓSpec.adjunction.unit.app (X ∣_ᵤ U)) ⊤ ≫
        X.presheaf.map (eqToHom ⋯).op ≫
          X.presheaf.map (eqToHom ⋯).op ≫
            Scheme.Hom.app (asIso (ΓSpec.adjunction.unit.app (X.restrict ⋯))).inv (Scheme.ιOpens U ⁻¹ᵁ U) ≫
              Scheme.Hom.app (Spec.map (X.presheaf.map (eqToHom ⋯).op))
                (((asIso (ΓSpec.adjunction.unit.app (X.restrict ⋯))).inv ≫ Scheme.ιOpens U) ⁻¹ᵁ U) =
    (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op

tactic: dsimp only [asIso_inv, Functor.op_obj, unop_op]
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
this : IsAffine (X.restrict ⋯)
⊢ Scheme.Γ.map (Spec.map (X.presheaf.map (eqToHom ⋯).op)).op ≫
      Scheme.Hom.app (ΓSpec.adjunction.unit.app (X ∣_ᵤ U)) ⊤ ≫
        X.presheaf.map (eqToHom ⋯).op ≫
          X.presheaf.map (eqToHom ⋯).op ≫
            Scheme.Hom.app (asIso (ΓSpec.adjunction.unit.app (X.restrict ⋯))).inv (Scheme.ιOpens U ⁻¹ᵁ U) ≫
              Scheme.Hom.app (Spec.map (X.presheaf.map (eqToHom ⋯).op))
                (((asIso (ΓSpec.adjunction.unit.app (X.restrict ⋯))).inv ≫ Scheme.ιOpens U) ⁻¹ᵁ U) =
    (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
this : IsAffine (X.restrict ⋯)
⊢ Scheme.Γ.map (Spec.map (X.presheaf.map (eqToHom ⋯).op)).op ≫
      Scheme.Hom.app (ΓSpec.adjunction.unit.app (X ∣_ᵤ U)) ⊤ ≫
        X.presheaf.map (eqToHom ⋯).op ≫
          X.presheaf.map (eqToHom ⋯).op ≫
            Scheme.Hom.app (inv (ΓSpec.adjunction.unit.app (X.restrict ⋯))) (Scheme.ιOpens U ⁻¹ᵁ U) ≫
              Scheme.Hom.app (Spec.map (X.presheaf.map (eqToHom ⋯).op))
                ((inv (ΓSpec.adjunction.unit.app (X.restrict ⋯)) ≫ Scheme.ιOpens U) ⁻¹ᵁ U) =
    (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op

tactic: rw [← Functor.map_comp_assoc, ← op_comp, eqToHom_trans, Scheme.eq_restrict_presheaf_map_eqToHom,
  Scheme.Hom.naturality_assoc, Scheme.inv_app_top, IsIso.hom_inv_id_assoc]
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
this : IsAffine (X.restrict ⋯)
⊢ Scheme.Γ.map (Spec.map (X.presheaf.map (eqToHom ⋯).op)).op ≫
      Scheme.Hom.app (ΓSpec.adjunction.unit.app (X ∣_ᵤ U)) ⊤ ≫
        X.presheaf.map (eqToHom ⋯).op ≫
          X.presheaf.map (eqToHom ⋯).op ≫
            Scheme.Hom.app (inv (ΓSpec.adjunction.unit.app (X.restrict ⋯))) (Scheme.ιOpens U ⁻¹ᵁ U) ≫
              Scheme.Hom.app (Spec.map (X.presheaf.map (eqToHom ⋯).op))
                ((inv (ΓSpec.adjunction.unit.app (X.restrict ⋯)) ≫ Scheme.ιOpens U) ⁻¹ᵁ U) =
    (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
this : IsAffine (X.restrict ⋯)
⊢ Scheme.Γ.map (Spec.map (X.presheaf.map (eqToHom ⋯).op)).op ≫
      (Spec Γ(X, ⋯.functor.obj ⊤)).presheaf.map
          ((Opens.map (inv (ΓSpec.adjunction.unit.app (X.restrict ⋯))).val.base).map (eqToHom ⋯).op.unop).op ≫
        Scheme.Hom.app (Spec.map (X.presheaf.map (eqToHom ⋯).op))
          ((inv (ΓSpec.adjunction.unit.app (X.restrict ⋯)) ≫ Scheme.ιOpens U) ⁻¹ᵁ U) =
    (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op

tactic: simp only [eqToHom_op, eqToHom_map, Spec.map_eqToHom, eqToHom_unop,
  Scheme.Spec_map_presheaf_map_eqToHom, eqToHom_trans]
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
this : IsAffine (X.restrict ⋯)
⊢ Scheme.Γ.map (Spec.map (X.presheaf.map (eqToHom ⋯).op)).op ≫
      (Spec Γ(X, ⋯.functor.obj ⊤)).presheaf.map
          ((Opens.map (inv (ΓSpec.adjunction.unit.app (X.restrict ⋯))).val.base).map (eqToHom ⋯).op.unop).op ≫
        Scheme.Hom.app (Spec.map (X.presheaf.map (eqToHom ⋯).op))
          ((inv (ΓSpec.adjunction.unit.app (X.restrict ⋯)) ≫ Scheme.ιOpens U) ⁻¹ᵁ U) =
    (Spec Γ(X, U)).presheaf.map (eqToHom ⋯).op
state_after: no goals