import OAI.AlgebraicGeometry.SurfaceCones.AffineExteriorSections
import OAI.AlgebraicGeometry.SurfaceCones.ScalarPullback

namespace OAI

private local instance frameFiniteQuasicoherent {Z : AlgebraicGeometry.Scheme.{0}}
    (M : Z.Modules) [M.IsFinitePresentation] : M.IsQuasicoherent :=
  (SheafOfModules.IsFinitePresentation.exists_quasicoherentData M).choose.isQuasicoherent

/-! An affine module basis induces a line frame in its associated sheaf. -/
noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite
namespace ActualLineFrames
variable {Y : Scheme.{0}} (R : Type) [CommRing R]
  (i : Spec (.of R) ⟶ Y) [IsOpenImmersion i]
  (M : Y.Modules) (N : ModuleCat R) (e : M.restrict i ≅ tilde N)
  (b : N ≅ ModuleCat.of R R)

local instance (U : (Spec (.of R)).Opens) : Algebra R Γ(Spec (.of R),U) :=
  inferInstanceAs (Algebra R ((Spec.structureSheaf R).obj.obj (.op U)))

lemma tildeSelf_inv_one : (tildeSelf (R := .of R)).inv.val.app (op ⊤)
    (1 : Γ(Spec (.of R),⊤)) = tilde.toOpen (R := .of R) (ModuleCat.of R R) ⊤ 1 := by
  change (1 : Γ(Spec (.of R),⊤)) = algebraMap R Γ(Spec (.of R),⊤) 1
  exact (map_one _).symm

lemma affineUnit_chartFrame :
    chartFrame i (e ≪≫ (tilde.functor (.of R)).mapIso b ≪≫ tildeSelf) =
      ActualSections.affineSection R i M N e (b.inv 1) := by
  unfold chartFrame ActualSections.affineSection
  change e.inv.val.app (op ⊤)
    ((tilde.map b.inv).val.app (op ⊤)
      ((tildeSelf (R := .of R)).inv.val.app (op ⊤) (1 : Γ(Spec (.of R),⊤)))) = _
  rw [tildeSelf_inv_one]
  exact congrArg (e.inv.val.app (op ⊤))
    (ConcreteCategory.congr_hom (tilde.toOpen_map_app (R := .of R) b.inv ⊤) 1)
end ActualLineFrames

end

/-! The canonical top-form sections are frames on the coefficient-chart cover. -/
noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite
namespace SourceSymmetry
open ExplicitCone ActualLineFrames
lemma coefficientCanonicalIso_eq_top (t : SectionIndex) (ht : Good t) :
    coefficientCanonicalIso t ht =
      ActualCotangent.topOpenAffineIso projectiveSurfaceToComplex (coefficientChart t)
        (coefficientIota t ht) (coefficientIota_toComplex t ht) := rfl

lemma canonicalFrameSection_affine (t : SectionIndex) (ht : Good t) :
    canonicalFrameSection t ht = ActualSections.affineSection (coefficientChart t)
      (coefficientIota t ht) canonicalSheaf _ (coefficientCanonicalIso t ht)
      (coefficientCanonicalGenerator t ht) := by
  unfold canonicalFrameSection ActualCotangent.topChartSection
  rw [← coefficientCanonicalIso_eq_top]
  rfl

lemma canonicalFrameSection_chartFrame (t : SectionIndex) (ht : Good t) :
    canonicalFrameSection t ht =
      chartFrame (coefficientIota t ht) (coefficientCanonicalUnitIso t ht) := by
  rw [canonicalFrameSection_affine]
  exact (affineUnit_chartFrame (coefficientChart t) (coefficientIota t ht) canonicalSheaf
    _ (coefficientCanonicalIso t ht) (coefficientCanonicalFrame t ht).toModuleIso).symm

instance canonicalFrameSection_isIso (t : SectionIndex) (ht : Good t) :
    IsIso (overFromSection canonicalSheaf (coefficientIota t ht ''ᵁ ⊤)
      (canonicalFrameSection t ht)) := by
  rw [canonicalFrameSection_chartFrame]
  exact chartFrame_isIso (coefficientIota t ht) (coefficientCanonicalUnitIso t ht)

def canonicalOpenUnitIso (t : SectionIndex) (ht : Good t) :
    canonicalSheaf.over (coefficientIota t ht ''ᵁ ⊤) ≅
      SheafOfModules.unit (projectiveSurface.ringCatSheaf.over (coefficientIota t ht ''ᵁ ⊤)) :=
  (asIso (overFromSection canonicalSheaf (coefficientIota t ht ''ᵁ ⊤)
    (canonicalFrameSection t ht))).symm
lemma canonicalOpenUnitIso_frame (t : SectionIndex) (ht : Good t)
    (V : projectiveSurface.Opens) (h : V ≤ coefficientIota t ht ''ᵁ ⊤) :
    frame (canonicalOpenUnitIso t ht) V h =
      canonicalSheaf.val.map (homOfLE h).op (canonicalFrameSection t ht) :=
  overFromSection_frame (canonicalFrameSection t ht) V h
end SourceSymmetry

end

/-! Sections are determined by their pullbacks to an open cover. -/
noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite
namespace ActualSections
universe u
variable {X : Scheme.{u}} {ι : Type*} (Y : ι → Scheme.{u})
  (j : ∀ i, Y i ⟶ X) [∀ i, IsOpenImmersion (j i)]
  (hc : (⨆ i, (j i).opensRange) = ⊤)
include hc in
lemma section_eq_of_appTop {a b : Γ(X,⊤)}
    (h : ∀ i, (j i).appTop a = (j i).appTop b) : a = b := by
  apply X.IsSheaf.section_ext
  intro x hx
  have hx' : x ∈ ⨆ i, (j i).opensRange := by rw [hc]; trivial
  obtain ⟨i, hi⟩ := TopologicalSpace.Opens.mem_iSup.mp hx'
  refine ⟨(j i) ''ᵁ ⊤, le_top, ?_, ?_⟩
  · simpa only [Scheme.Hom.image_top_eq_opensRange] using hi
  · apply (ConcreteCategory.bijective_of_isIso ((j i).appIso ⊤).hom).1
    have he : X.presheaf.map (homOfLE (show (j i) ''ᵁ ⊤ ≤ ⊤ from le_top)).op ≫
        ((j i).appIso ⊤).hom = (j i).appTop := by
      rw [Scheme.Hom.appIso_hom', Scheme.Hom.map_appLE]
      erw [Scheme.Hom.appLE_eq_app]
    simpa only [← ConcreteCategory.comp_apply, he] using h i
end ActualSections

end

/-! Degree-one elements of the section ring give sections of the exceptional ideal. -/
noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite
namespace AlgebraicGeometry.Scheme
open scoped _root_.AlgebraicGeometry _root_.AlgebraicGeometry.Scheme
universe u
variable {X Y Z : _root_.AlgebraicGeometry.Scheme.{u}} {R B : Type u} [CommRing R] [CommRing B]
lemma coordinateMap_precomp_apply (α : Z ⟶ Y) (f : Y ⟶ _root_.AlgebraicGeometry.Spec (.of R)) (a : R) :
    coordinateMap (α ≫ f) a = α.appTop (coordinateMap f a) :=
  RingHom.congr_fun (coordinateMap_precomp α f) a
lemma coordinateMap_spec (φ : R →+* B) :
    coordinateMap (_root_.AlgebraicGeometry.Spec.map (CommRingCat.ofHom φ)) =
      (_root_.AlgebraicGeometry.Scheme.ΓSpecIso (.of B)).inv.hom.comp φ := by
  unfold coordinateMap
  rw [← _root_.AlgebraicGeometry.Scheme.ΓSpecIso_inv_naturality]
  rfl
lemma coordinateMap_ideal_of_cover {ι : Type*} (U : ι → _root_.AlgebraicGeometry.Scheme.{u})
    (j : ∀ i, U i ⟶ X) [∀ i, _root_.AlgebraicGeometry.IsOpenImmersion (j i)]
    (hc : (⨆ i, (j i).opensRange) = ⊤)
    (f : X ⟶ Y) (g : Y ⟶ _root_.AlgebraicGeometry.Spec (.of R)) (a : R)
    (h : ∀ i, coordinateMap (j i ≫ f ≫ g) a = 0) :
    f.app ⊤ (coordinateMap g a) = 0 := by
  apply ActualSections.section_eq_of_appTop U j hc
  intro i
  erw [map_zero]
  change (j i).appTop (f.appTop (coordinateMap g a)) = 0
  exact (congrArg (j i).appTop (coordinateMap_precomp_apply f g a)).symm.trans
    ((coordinateMap_precomp_apply (j i) (f ≫ g) a).symm.trans (h i))
end AlgebraicGeometry.Scheme
namespace SourcePullbackChart
open KummerSourceModel SourceZeroSections SectionCompletion
attribute [local instance] integralSurfaceCommRing integralSurfaceSemiring
  integralPullbackCommRing integralPullbackSemiring pullbackBaseAlgebra surfaceOriginAlgebra
  completedPullbackModule completedPullbackAction completedPullbackSMul completedPullbackTower
  completedSurfaceModule completedSeriesModule completedSourceChartCommRing completedSourceChartSemiring
  completedSourceAlgebra
  originChartCommRing originChartSemiring originPlaneCommRing originPlaneSemiring
  chartBaseAlgebra planeOriginAlgebra baseChartModule baseChartAction baseChartSMul baseChartTower
  planeOriginModule completedBlowupCommRing completedBlowupSemiring completedBlowupAlgebra

def degreeOneFunction (c : ExplicitCone.L) (hc : c ∈ ExplicitCone.pieces 1) : Γ(W,⊤) :=
  Scheme.coordinateMap (SourceConeMorphism.forgetCompletion ≫ coneMorphism)
    (linearSection ExplicitCone.pieces c hc)

lemma degreeOneFunction_vanishes (c : ExplicitCone.L) (hc : c ∈ ExplicitCone.pieces 1) :
    completedSourceZero.app ⊤ (degreeOneFunction c hc) = 0 := by
  apply Scheme.coordinateMap_ideal_of_cover
    (fun i : Fin 3 => Spec (.of (surfaceChart i))) surfaceIota surfaceIota_cover
    completedSourceZero (SourceConeMorphism.forgetCompletion ≫ coneMorphism)
    (linearSection ExplicitCone.pieces c hc)
  intro i
  rw [← Category.assoc completedSourceZero,
    completedSourceZero_forget, ← Category.assoc, surfaceIota_sourceZero,
    Category.assoc, pullbackIota_coneMorphism, ← Spec.map_comp,
    ← CommRingCat.ofHom_comp, Scheme.coordinateMap_spec]
  change (Scheme.ΓSpecIso (.of (surfaceChart i))).inv
    (pullbackZeroEvaluation i (coneEvaluation i
      (linearSection ExplicitCone.pieces c hc))) = 0
  rw [coneEvaluation_homogeneous i 1 _ (linearSection_homogeneous ExplicitCone.pieces c hc),
    map_mul, map_pow, pullbackZeroEvaluation_fiber, zero_pow (by decide : 1 ≠ 0),
    mul_zero, map_zero]

/-- degree-one global section of the Cartier ideal. -/
def degreeOneIdealGenerator (c : ExplicitCone.L) (hc : c ∈ ExplicitCone.pieces 1) :
    SheafOfModules.unit W.ringCatSheaf ⟶ ActualCartier.idealSheaf completedSourceZero :=
  ActualCartier.idealGenerator completedSourceZero (degreeOneFunction c hc)
    (degreeOneFunction_vanishes c hc)

/-- Degree-one section of the conormal line on the source X. -/
def degreeOneConormalGenerator (c : ExplicitCone.L) (hc : c ∈ ExplicitCone.pieces 1) :
    SheafOfModules.unit ExplicitCone.projectiveSurface.ringCatSheaf ⟶
      (Scheme.Modules.pullback completedSourceZero).obj
        (ActualCartier.idealSheaf completedSourceZero) :=
  (ActualSheafTensor.sheafPullbackUnitIso completedSourceZero).inv ≫
    (Scheme.Modules.pullback completedSourceZero).map (degreeOneIdealGenerator c hc)
end SourcePullbackChart

end

/-! Local equations for degree-one sections of the exceptional ideal. -/
noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite TensorProduct
namespace SourcePullbackChart
open KummerSourceModel SourceZeroSections SectionCompletion
  Scheme.Modules ActualCartier ActualSections ActualSheafTensor
attribute [local instance] integralSurfaceCommRing integralSurfaceSemiring
  integralPullbackCommRing integralPullbackSemiring pullbackBaseAlgebra surfaceOriginAlgebra
  completedPullbackModule completedPullbackAction completedPullbackSMul completedPullbackTower
  completedSurfaceModule completedSeriesModule completedSourceChartCommRing completedSourceChartSemiring
  completedSourceAlgebra
  originChartCommRing originChartSemiring originPlaneCommRing originPlaneSemiring
  chartBaseAlgebra planeOriginAlgebra baseChartModule baseChartAction baseChartSMul baseChartTower
  planeOriginModule completedBlowupCommRing completedBlowupSemiring completedBlowupAlgebra

def degreeOneCoefficient (i : Fin 3) (c : ExplicitCone.L) (hc : c ∈ ExplicitCone.pieces 1) :
    surfaceChart i :=
  dehomogenize ExplicitCone.pieces (ExplicitCone.projectiveParameter i)
    (ExplicitCone.projectiveParameter_mem i) (ExplicitCone.projectiveParameter_ne_zero i)
    (linearSection ExplicitCone.pieces c hc)

lemma degreeOneCoefficient_self (i : Fin 3) :
    degreeOneCoefficient i (ExplicitCone.projectiveParameter i)
      (ExplicitCone.projectiveParameter_mem i) = 1 := by
  apply homogeneousChartMap_injective ExplicitCone.pieces (ExplicitCone.projectiveParameter i)
    (ExplicitCone.projectiveParameter_mem i) (ExplicitCone.projectiveParameter_ne_zero i)
  rw [degreeOneCoefficient, homogeneousChartMap_dehomogenize, map_one,
    evaluateInv_homogeneous _ _ 1 _ (linearSection_homogeneous _ _ _)]
  simp only [linearSection, Polynomial.coeff_monomial, ite_true, pow_one,
    div_self (ExplicitCone.projectiveParameter_ne_zero i)]

def completedDegreeOneCoefficient (i : Fin 3) (c : ExplicitCone.L)
    (hc : c ∈ ExplicitCone.pieces 1) : completedSourceChart i :=
  surfaceIn i (degreeOneCoefficient i c hc) ⊗ₜ[S] (1 : A)

lemma degreeOneFunction_chart (i : Fin 3) (c : ExplicitCone.L)
    (hc : c ∈ ExplicitCone.pieces 1) :
    (completedIota i).appTop (degreeOneFunction c hc) =
      (Scheme.ΓSpecIso (.of (completedSourceChart i))).inv
        (completedDegreeOneCoefficient i c hc * completedFiberParameter i) := by
  have he := (Scheme.coordinateMap_precomp_apply (completedIota i)
    (SourceConeMorphism.forgetCompletion ≫ coneMorphism)
    (linearSection ExplicitCone.pieces c hc)).symm
  change (completedIota i).appTop (degreeOneFunction c hc) = _ at he
  rw [← Category.assoc, completedIota_forget, Category.assoc, pullbackIota_coneMorphism,
    completedChartFirst, ← Spec.map_comp, ← CommRingCat.ofHom_comp,
    Scheme.coordinateMap_spec] at he
  refine he.trans ?_
  change (Scheme.ΓSpecIso (.of (completedSourceChart i))).inv
    (coneEvaluation i (linearSection ExplicitCone.pieces c hc) ⊗ₜ[S] (1 : A)) = _
  rw [coneEvaluation_homogeneous i 1 _ (linearSection_homogeneous _ _ _), pow_one]
  congr 1
  change (surfaceIn i (degreeOneCoefficient i c hc) * fiberParameter i) ⊗ₜ[S] (1 : A) =
    (surfaceIn i (degreeOneCoefficient i c hc) ⊗ₜ[S] (1 : A)) * (fiberParameter i ⊗ₜ[S] (1 : A))
  exact (Algebra.TensorProduct.includeLeft : pullbackChart i →ₐ[S] completedSourceChart i).map_mul
    (surfaceIn i (degreeOneCoefficient i c hc)) (fiberParameter i)

lemma degreeOneParameter_chart (i : Fin 3) :
    (completedIota i).appTop
      (degreeOneFunction (ExplicitCone.projectiveParameter i) (ExplicitCone.projectiveParameter_mem i)) =
      (Scheme.ΓSpecIso (.of (completedSourceChart i))).inv (completedFiberParameter i) := by
  rw [degreeOneFunction_chart, completedDegreeOneCoefficient, degreeOneCoefficient_self,
    map_one]
  change (Scheme.ΓSpecIso (.of (completedSourceChart i))).inv (1 * completedFiberParameter i) = _
  rw [one_mul]

lemma degreeOneFunction_chart_ratio (i : Fin 3) (c : ExplicitCone.L)
    (hc : c ∈ ExplicitCone.pieces 1) :
    (completedIota i).appTop (degreeOneFunction c hc) =
      (Scheme.ΓSpecIso (.of (completedSourceChart i))).inv (completedDegreeOneCoefficient i c hc) *
        (completedIota i).appTop
          (degreeOneFunction (ExplicitCone.projectiveParameter i)
            (ExplicitCone.projectiveParameter_mem i)) := by
  rw [degreeOneFunction_chart, degreeOneParameter_chart, map_mul]

lemma degreeOneParameterIdeal_chart_isIso (i : Fin 3) :
    IsIso ((restrictFunctor (completedIota i)).map
      (degreeOneIdealGenerator (ExplicitCone.projectiveParameter i)
        (ExplicitCone.projectiveParameter_mem i))) := by
  have : (idealSheaf completedSourceZero).IsFinitePresentation := idealSheaf_coherent _
  have : ((restrictFunctor (completedIota i)).obj (idealSheaf completedSourceZero)).IsFinitePresentation :=
    CoherentGlobal.coherent_restrict _ _
  have hi := chartGenerator_isIso completedSourceZero (completedZeroChart i)
    (surfaceIota i) (completedIota i) (surfaceIota_completedSourceZero i)
    (by simpa only [Scheme.Hom.image_top_eq_opensRange] using (surfaceZero_chart_preimage i).symm)
    (degreeOneFunction (ExplicitCone.projectiveParameter i) (ExplicitCone.projectiveParameter_mem i))
    (degreeOneFunction_vanishes _ _)
    (by rw [degreeOneParameter_chart]; exact specInverse_regular _ (completedFiberParameter_regular i))
    (by rw [degreeOneParameter_chart]; exact specMap_app_kernel _ _ (completedZeroEvaluation_kernel i))
  exact @IsIso.of_isIso_comp_left _ _ _ _ _ _ _
    (restrictUnitIso (completedIota i)).isIso_inv hi

lemma completedDegreeOneCoefficient_residue (i : Fin 3) (c : ExplicitCone.L)
    (hc : c ∈ ExplicitCone.pieces 1) :
    completedZeroEvaluation i (completedDegreeOneCoefficient i c hc) =
      degreeOneCoefficient i c hc := by
  rw [completedDegreeOneCoefficient, completedZeroEvaluation_tmul, map_one, map_one,
    mul_one, pullbackZeroEvaluation_surface]

end SourcePullbackChart

end

/-! Transport of section ratios across commuting affine open charts. -/
noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite
namespace ActualSections
open Scheme.Modules ActualSheafTensor
variable {X : Scheme.{0}}
private lemma map_ratio_of_commute {C D : Type*} [Category C] [Category D]
    (F : C ⥤ D) {U V W : C} {Q : D} (l : Q ⟶ F.obj U)
    (a : U ⟶ U) (b : Q ⟶ Q) (p : U ⟶ V) (s t : V ⟶ W)
    (h : p ≫ s = a ≫ p ≫ t) (hc : l ≫ F.map a = b ≫ l) :
    (l ≫ F.map p) ≫ F.map s = b ≫ (l ≫ F.map p) ≫ F.map t := by
  calc
    (l ≫ F.map p) ≫ F.map s = l ≫ F.map (p ≫ s) := by
      rw [F.map_comp, Category.assoc]
    _ = l ≫ F.map (a ≫ p ≫ t) := congrArg (fun z => l ≫ F.map z) h
    _ = (l ≫ F.map a) ≫ (F.map p ≫ F.map t) := by
      rw [F.map_comp, F.map_comp, Category.assoc]
    _ = (b ≫ l) ≫ (F.map p ≫ F.map t) := congrArg (· ≫ (F.map p ≫ F.map t)) hc
    _ = b ≫ (l ≫ F.map p) ≫ F.map t := by simp only [Category.assoc]

lemma unit_scalar_comm (a : Γ(X,⊤))
    (u : SheafOfModules.unit X.ringCatSheaf ⟶ SheafOfModules.unit X.ringCatSheaf) :
    u ≫ scalar a = scalar a ≫ u := by
  apply unitHom_ext_top
  change (scalar a).val.app (op ⊤) (u.val.app (op ⊤) (1 : Γ(X,⊤))) =
    u.val.app (op ⊤) ((scalar a).val.app (op ⊤) (1 : Γ(X,⊤)))
  erw [fromUnit_top, fromUnit_top, one_smul]
  let v : Γ(X,⊤) →ₗ[Γ(X,⊤)] Γ(X,⊤) := (u.val.app (op ⊤)).hom
  change v 1 * a = v a
  have hu := v.map_smul a 1
  change v (a * 1) = a * v 1 at hu
  simpa only [mul_one, mul_comm] using hu.symm

universe v
variable {C : Type v} [Category C]
lemma ratio_across_natIso (F G : C ⥤ X.Modules) (e : F ≅ G) {D M : C}
    (s t : D ⟶ M)
    (p : SheafOfModules.unit X.ringCatSheaf ⟶ F.obj D)
    (q : SheafOfModules.unit X.ringCatSheaf ≅ G.obj D) (a : Γ(X,⊤))
    (h : q.hom ≫ G.map s = scalar a ≫ q.hom ≫ G.map t) :
    p ≫ F.map s = scalar a ≫ p ≫ F.map t := by
  apply (cancel_mono (e.app M).hom).mp
  change p ≫ (F.map s ≫ e.hom.app M) = scalar a ≫ p ≫ (F.map t ≫ e.hom.app M)
  erw [e.hom.naturality s, e.hom.naturality t]
  let u := p ≫ (e.app D).hom ≫ q.inv
  have hu : u ≫ q.hom = p ≫ (e.app D).hom := by
    dsimp only [u]
    erw [Category.assoc, Category.assoc, Iso.inv_hom_id, Category.comp_id]
  calc
    p ≫ (e.app D).hom ≫ G.map s = u ≫ q.hom ≫ G.map s := by
      erw [← Category.assoc u, hu]
      erw [Category.assoc]
    _ = u ≫ scalar a ≫ q.hom ≫ G.map t := by erw [h]
    _ = scalar a ≫ u ≫ q.hom ≫ G.map t := by
      erw [← Category.assoc u, unit_scalar_comm]
      erw [Category.assoc]
    _ = scalar a ≫ p ≫ (e.app D).hom ≫ G.map t := by
      erw [← Category.assoc u, hu]
      erw [Category.assoc]

end ActualSections

namespace ActualChartPullback
open Scheme.Modules ActualSections ActualSheafTensor
variable {A B C D : Scheme.{0}}
  (j : C ⟶ A) (f : A ⟶ B) (q : C ⟶ D) (k : D ⟶ B)
  [IsOpenImmersion j] [IsOpenImmersion k] (h : j ≫ f = q ≫ k)

include h in
lemma section_ratio {M : B.Modules}
    (s t : SheafOfModules.unit B.ringCatSheaf ⟶ M) (a : Γ(D,⊤))
    (hr : (restrictUnitIso k).inv ≫ (restrictFunctor k).map s =
      scalar a ≫ (restrictUnitIso k).inv ≫ (restrictFunctor k).map t) :
    (restrictUnitIso j).inv ≫ (restrictFunctor j).map
        ((sheafPullbackUnitIso f).inv ≫ (Scheme.Modules.pullback f).map s) =
    scalar (q.appTop a) ≫ (restrictUnitIso j).inv ≫ (restrictFunctor j).map
        ((sheafPullbackUnitIso f).inv ≫ (Scheme.Modules.pullback f).map t) := by
  let e := (sheafPullbackUnitIso q).symm ≪≫
    (Scheme.Modules.pullback q).mapIso (restrictUnitIso k).symm
  have he : e.hom ≫ (restrictFunctor k ⋙ Scheme.Modules.pullback q).map s =
      scalar (q.appTop a) ≫ e.hom ≫
        (restrictFunctor k ⋙ Scheme.Modules.pullback q).map t := by
    exact map_ratio_of_commute (Scheme.Modules.pullback q) (sheafPullbackUnitIso q).inv
      (scalar a) (scalar (q.appTop a)) (restrictUnitIso k).inv
      ((restrictFunctor k).map s) ((restrictFunctor k).map t) hr
      (pullback_scalar_inv q a)
  have hh := ratio_across_natIso
    (Scheme.Modules.pullback f ⋙ restrictFunctor j)
    (restrictFunctor k ⋙ Scheme.Modules.pullback q) (squareIso j f q k h)
    s t ((restrictUnitIso j).inv ≫ (restrictFunctor j).map (sheafPullbackUnitIso f).inv)
    e (q.appTop a) he
  let F : A.Modules ⥤ C.Modules := restrictFunctor j
  let l := (restrictUnitIso j).inv
  let p := (sheafPullbackUnitIso f).inv
  let u := (Scheme.Modules.pullback f).map s
  let v := (Scheme.Modules.pullback f).map t
  let b := scalar (q.appTop a)
  exact (congrArg (l ≫ ·) (F.map_comp p u)).trans
    ((Category.assoc l (F.map p) (F.map u)).symm.trans
      (hh.trans
        ((congrArg (b ≫ ·) (Category.assoc l (F.map p) (F.map v))).trans
          (congrArg (fun z => b ≫ l ≫ z) (F.map_comp p v).symm))))
end ActualChartPullback

end

/-! Open restriction preserves section ratios and frames. -/
noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite
namespace ActualSections
open Scheme.Modules ActualSheafTensor
variable {X Y : Scheme.{0}} (j : X ⟶ Y) [IsOpenImmersion j]
lemma restrict_scalar_inv (a : Γ(Y,⊤)) :
    (restrictUnitIso j).inv ≫ (restrictFunctor j).map (scalar a) =
      scalar (j.appTop a) ≫ (restrictUnitIso j).inv := by
  have : Mono (restrictUnitIso j).hom :=
    @IsIso.mono_of_iso _ _ _ _ _ (restrictUnitIso j).isIso_hom
  apply (cancel_mono (restrictUnitIso j).hom).mp
  erw [Category.assoc (restrictUnitIso j).inv,
    Category.assoc (scalar (j.appTop a)), Iso.inv_hom_id, Category.comp_id]
  apply unitHom_ext_top
  erw [restrictScalar_top]
  change j.appTop a * 1 = _
  erw [fromUnit_top, mul_one, one_smul]

lemma scalar_isIso (a : Γ(X,⊤)) (ha : IsUnit a) : IsIso (scalar a) := by
  obtain ⟨u, rfl⟩ := ha
  refine ⟨⟨scalar (↑u⁻¹ : Γ(X,⊤)), ?_, ?_⟩⟩ <;>
    apply unitHom_ext_top <;>
    simp only [SheafOfModules.comp_val]
  · change (scalar (↑u⁻¹ : Γ(X,⊤))).val.app (op ⊤)
        ((scalar (↑u : Γ(X,⊤))).val.app (op ⊤) (1 : Γ(X,⊤))) = (1 : Γ(X,⊤))
    erw [fromUnit_top, fromUnit_top, one_smul]
    exact u.val_inv
  · change (scalar (↑u : Γ(X,⊤))).val.app (op ⊤)
        ((scalar (↑u⁻¹ : Γ(X,⊤))).val.app (op ⊤) (1 : Γ(X,⊤))) = (1 : Γ(X,⊤))
    erw [fromUnit_top, fromUnit_top, one_smul]
    exact u.inv_val

lemma scalar_comp_congr {Z : Scheme.{0}} {M : Z.Modules}
    {a b : Γ(Z,⊤)} (h : a = b) (s : SheafOfModules.unit Z.ringCatSheaf ⟶ M) :
    scalar a ≫ s = scalar b ≫ s := by subst h; rfl

end ActualSections
namespace ActualChartPullback
open Scheme.Modules ActualSections ActualSheafTensor
variable {A B C D : Scheme.{0}}
  (j : C ⟶ A) (f : A ⟶ B) (q : C ⟶ D) (k : D ⟶ B)
  [IsOpenImmersion j] [IsOpenImmersion k] (h : j ≫ f = q ≫ k)
include h in
lemma section_ratio_eq {M : B.Modules}
    (s t : SheafOfModules.unit B.ringCatSheaf ⟶ M) (a : Γ(D,⊤)) (b : Γ(C,⊤))
    (hab : q.appTop a = b)
    (hr : (restrictUnitIso k).inv ≫ (restrictFunctor k).map s =
      scalar a ≫ (restrictUnitIso k).inv ≫ (restrictFunctor k).map t) :
    (restrictUnitIso j).inv ≫ (restrictFunctor j).map
        ((sheafPullbackUnitIso f).inv ≫ (Scheme.Modules.pullback f).map s) =
    scalar b ≫ (restrictUnitIso j).inv ≫ (restrictFunctor j).map
        ((sheafPullbackUnitIso f).inv ≫ (Scheme.Modules.pullback f).map t) := by
  simpa only [hab] using section_ratio j f q k h s t a hr

include h in
lemma section_isIso {M : B.Modules} (s : SheafOfModules.unit B.ringCatSheaf ⟶ M)
    [IsIso ((restrictFunctor k).map s)] :
    IsIso ((restrictUnitIso j).inv ≫ (restrictFunctor j).map
      ((sheafPullbackUnitIso f).inv ≫ (Scheme.Modules.pullback f).map s)) := by
  have hs := map_isIso j f q k h s
  have hu : IsIso ((restrictFunctor j).map (sheafPullbackUnitIso f).inv) :=
    ((restrictFunctor j).mapIso (sheafPullbackUnitIso f).symm).isIso_hom
  erw [Functor.map_comp]
  exact IsIso.comp_isIso' (restrictUnitIso j).isIso_inv (IsIso.comp_isIso' hu hs)
end ActualChartPullback

end

/-! Degree-one conormal sections and their projective ratios. -/
noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite TensorProduct
namespace SourcePullbackChart
open KummerSourceModel SourceZeroSections SectionCompletion
  Scheme.Modules ActualCartier ActualSections ActualSheafTensor
attribute [local instance] integralSurfaceCommRing integralSurfaceSemiring
  integralPullbackCommRing integralPullbackSemiring pullbackBaseAlgebra surfaceOriginAlgebra
  completedPullbackModule completedPullbackAction completedPullbackSMul completedPullbackTower
  completedSurfaceModule completedSeriesModule completedSourceChartCommRing completedSourceChartSemiring
  completedSourceAlgebra

def degreeOneConormalChartSection (i : Fin 3) (c : ExplicitCone.L)
    (hc : c ∈ ExplicitCone.pieces 1) :
    SheafOfModules.unit (Spec (.of (surfaceChart i))).ringCatSheaf ⟶
      (restrictFunctor (surfaceIota i)).obj
        ((Scheme.Modules.pullback completedSourceZero).obj (idealSheaf completedSourceZero)) :=
  (restrictUnitIso (surfaceIota i)).inv ≫
    (restrictFunctor (surfaceIota i)).map (degreeOneConormalGenerator c hc)

lemma degreeOneParameterConormal_chart_isIso (i : Fin 3) :
    IsIso (degreeOneConormalChartSection i (ExplicitCone.projectiveParameter i)
      (ExplicitCone.projectiveParameter_mem i)) := by
  have := degreeOneParameterIdeal_chart_isIso i
  exact ActualChartPullback.section_isIso (surfaceIota i) completedSourceZero (completedZeroChart i)
    (completedIota i) (surfaceIota_completedSourceZero i)
    (degreeOneIdealGenerator (ExplicitCone.projectiveParameter i)
      (ExplicitCone.projectiveParameter_mem i))

lemma zeroChart_degreeOneCoefficient (i : Fin 3) (c : ExplicitCone.L)
    (hc : c ∈ ExplicitCone.pieces 1) :
    (completedZeroChart i).appTop
      ((Scheme.ΓSpecIso (.of (completedSourceChart i))).inv (completedDegreeOneCoefficient i c hc)) =
    (Scheme.ΓSpecIso (.of (surfaceChart i))).inv (degreeOneCoefficient i c hc) := by
  have he := ConcreteCategory.congr_hom (Scheme.ΓSpecIso_inv_naturality
    (CommRingCat.ofHom (completedZeroEvaluation i))).symm (completedDegreeOneCoefficient i c hc)
  change (completedZeroChart i).appTop _ = _ at he
  exact he.trans (congrArg (Scheme.ΓSpecIso (.of (surfaceChart i))).inv
    (completedDegreeOneCoefficient_residue i c hc))

end SourcePullbackChart

end

noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite TensorProduct
namespace SourcePullbackChart
open KummerSourceModel SourceZeroSections SectionCompletion
  Scheme.Modules ActualCartier ActualSections ActualSheafTensor
attribute [local instance] integralSurfaceCommRing integralSurfaceSemiring
  integralPullbackCommRing integralPullbackSemiring pullbackBaseAlgebra surfaceOriginAlgebra
  completedPullbackModule completedPullbackAction completedPullbackSMul completedPullbackTower
  completedSurfaceModule completedSeriesModule completedSourceChartCommRing completedSourceChartSemiring
  completedSourceAlgebra

lemma degreeOneConormalChartSection_ratio (i : Fin 3) (c : ExplicitCone.L)
    (hc : c ∈ ExplicitCone.pieces 1) :
    degreeOneConormalChartSection i c hc =
      scalar ((Scheme.ΓSpecIso (.of (surfaceChart i))).inv (degreeOneCoefficient i c hc)) ≫
        degreeOneConormalChartSection i (ExplicitCone.projectiveParameter i)
          (ExplicitCone.projectiveParameter_mem i) := by
  have hr := chartGenerator_ratio completedSourceZero (completedIota i)
    (degreeOneFunction (ExplicitCone.projectiveParameter i) (ExplicitCone.projectiveParameter_mem i))
    (degreeOneFunction c hc) (degreeOneFunction_vanishes _ _) (degreeOneFunction_vanishes _ _)
    _ (degreeOneFunction_chart_ratio i c hc)
  exact ActualChartPullback.section_ratio_eq (surfaceIota i) completedSourceZero
    (completedZeroChart i) (completedIota i) (surfaceIota_completedSourceZero i)
    (degreeOneIdealGenerator c hc)
    (degreeOneIdealGenerator (ExplicitCone.projectiveParameter i) (ExplicitCone.projectiveParameter_mem i))
    ((Scheme.ΓSpecIso (.of (completedSourceChart i))).inv (completedDegreeOneCoefficient i c hc))
    ((Scheme.ΓSpecIso (.of (surfaceChart i))).inv (degreeOneCoefficient i c hc))
    (zeroChart_degreeOneCoefficient i c hc) hr
end SourcePullbackChart

end

/-! Locality of line-section isomorphisms over scheme open covers. -/
noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite
namespace ActualSections
open Scheme.Modules
lemma isUnit_appTop_of_range {X Y : Scheme.{0}} (j : X ⟶ Y)
    (a : Γ(Y,⊤)) (ha : ∀ x : X, j x ∈ Y.basicOpen a) : IsUnit (j.appTop a) := by
  apply X.toRingedSpace.isUnit_of_isUnit_germ ⊤ (j.appTop a)
  intro x hx
  apply (Scheme.mem_basicOpen X (j.appTop a) x hx).mp
  rw [← j.preimage_basicOpen_top]
  exact ha x

lemma restrict_scalar_isIso {X Y : Scheme.{0}} (j : X ⟶ Y) [IsOpenImmersion j]
    (a : Γ(Y,⊤)) (ha : IsUnit (j.appTop a)) :
    IsIso ((restrictFunctor j).map (scalar a)) := by
  have hs := scalar_isIso (j.appTop a) ha
  have he := restrict_scalar_inv j a
  have hi : IsIso ((restrictUnitIso j).inv ≫ (restrictFunctor j).map (scalar a)) :=
    he.symm ▸ IsIso.comp_isIso' hs (restrictUnitIso j).isIso_inv
  exact @IsIso.of_isIso_comp_left _ _ _ _ _ _ _ (restrictUnitIso j).isIso_inv hi

lemma isIso_of_openImmersion_cover {Y : Scheme.{0}} {ι : Type} (X : ι → Scheme.{0})
    (j : ∀ i, X i ⟶ Y) [∀ i, IsOpenImmersion (j i)]
    (hc : (⨆ i, (j i).opensRange) = ⊤) {M N : Y.Modules} (f : M ⟶ N)
    (hf : ∀ i, IsIso ((restrictFunctor (j i)).map f)) : IsIso f := by
  apply CoherentGlobal.isIso_of_open_cover (fun i => (j i).opensRange) hc f
  intro i
  have := hf i
  let e := (restrictFunctorComp (j i).isoOpensRange.inv (j i)).symm ≪≫
    restrictFunctorCongr (Scheme.Hom.isoOpensRange_inv_comp (j i))
  have hx : IsIso ((restrictFunctor (j i) ⋙ restrictFunctor (j i).isoOpensRange.inv).map f) := by
    change IsIso ((restrictFunctor (j i).isoOpensRange.inv).map ((restrictFunctor (j i)).map f))
    infer_instance
  exact (NatIso.isIso_map_iff e f).mp hx

lemma restrict_cover_range {Y : Scheme.{0}} {ι : Type} (X : ι → Scheme.{0})
    (j : ∀ i, X i ⟶ Y) [∀ i, IsOpenImmersion (j i)]
    (hc : (⨆ i, (j i).opensRange) = ⊤) (U : Y.Opens) :
    (⨆ i, (j i ∣_ U).opensRange) = ⊤ := by
  have hp (i) : (j i ∣_ U).opensRange = U.ι ⁻¹ᵁ (j i).opensRange := by
    dsimp only [morphismRestrict]
    rw [Scheme.Hom.opensRange_comp_of_isIso, Scheme.Hom.opensRange_pullbackSnd]
  simp_rw [hp]
  rw [← Scheme.Hom.preimage_iSup, hc, Scheme.Hom.preimage_top]

lemma isIso_restrict_of_local_frames {Y : Scheme.{0}} {ι : Type} (X : ι → Scheme.{0})
    (j : ∀ i, X i ⟶ Y) [∀ i, IsOpenImmersion (j i)]
    (hc : (⨆ i, (j i).opensRange) = ⊤) (U : Y.Opens)
    {M : Y.Modules} (s : SheafOfModules.unit Y.ringCatSheaf ⟶ M)
    (t : ∀ i, SheafOfModules.unit (X i).ringCatSheaf ⟶ (restrictFunctor (j i)).obj M)
    (a : ∀ i, Γ(X i,⊤)) (ht : ∀ i, IsIso (t i))
    (hr : ∀ i, (restrictUnitIso (j i)).inv ≫ (restrictFunctor (j i)).map s =
      scalar (a i) ≫ t i)
    (hu : ∀ i, j i ⁻¹ᵁ U ≤ (X i).basicOpen (a i)) :
    IsIso ((restrictFunctor U.ι).map s) := by
  apply isIso_of_openImmersion_cover (fun i => (j i ⁻¹ᵁ U).toScheme)
    (fun i => j i ∣_ U) (restrict_cover_range X j hc U)
  intro i
  let F := restrictFunctor (j i ⁻¹ᵁ U).ι
  have hs : IsIso (F.map ((restrictFunctor (j i)).map s)) := by
    have hau : IsUnit ((j i ⁻¹ᵁ U).ι.appTop (a i)) :=
      isUnit_appTop_of_range (j i ⁻¹ᵁ U).ι (a i) (fun x => hu i x.property)
    have ha : IsIso (F.map (scalar (a i))) :=
      restrict_scalar_isIso (j i ⁻¹ᵁ U).ι (a i) hau
    have ht' : IsIso (F.map (t i)) := (F.mapIso (@asIso _ _ _ _ _ (ht i))).isIso_hom
    have hh : F.map (restrictUnitIso (j i)).inv ≫ F.map ((restrictFunctor (j i)).map s) =
        F.map (scalar (a i)) ≫ F.map (t i) :=
      (F.map_comp _ _).symm.trans ((congrArg F.map (hr i)).trans (F.map_comp _ _))
    have hm : IsIso (F.map (restrictUnitIso (j i)).inv ≫
        F.map ((restrictFunctor (j i)).map s)) :=
      hh.symm ▸ IsIso.comp_isIso' ha ht'
    exact @IsIso.of_isIso_comp_left _ _ _ _ _ _ _
      (F.mapIso (restrictUnitIso (j i)).symm).isIso_hom hm
  let e := (restrictFunctorComp (j i ∣_ U) U.ι).symm ≪≫
    restrictFunctorCongr (morphismRestrict_ι (j i) U) ≪≫
      restrictFunctorComp (j i ⁻¹ᵁ U).ι (j i)
  exact (NatIso.isIso_map_iff e s).mpr hs
end ActualSections

end

/-! A degree-one conormal section is a frame on its projective basic open. -/
noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite
namespace SourcePullbackChart
open ExplicitCone KummerSourceModel SourceZeroSections SectionCompletion
  Scheme.Modules ActualCartier ActualSections ActualSheafTensor
attribute [local instance] integralSurfaceCommRing integralSurfaceSemiring
  integralPullbackCommRing integralPullbackSemiring pullbackBaseAlgebra surfaceOriginAlgebra
  completedPullbackModule completedPullbackAction completedPullbackSMul completedPullbackTower
  completedSurfaceModule completedSeriesModule completedSourceChartCommRing completedSourceChartSemiring
  completedSourceAlgebra

lemma surfaceChart_degreeOne_open (i : Fin 3) (c : L) (hc : c ∈ pieces 1) :
    surfaceIota i ⁻¹ᵁ Proj.basicOpen (homogeneous pieces) (linearSection pieces c hc) =
      (Spec (.of (surfaceChart i))).basicOpen
        ((Scheme.ΓSpecIso (.of (surfaceChart i))).inv (degreeOneCoefficient i c hc)) := by
  rw [basicOpen_eq_of_affine]
  change Proj.awayι (homogeneous pieces) _ _ _ ⁻¹ᵁ
    Proj.basicOpen (homogeneous pieces) (linearSection pieces c hc) = _
  rw [Proj.awayι_preimage_basicOpen (homogeneous pieces) _ _
    (linearSection_homogeneous pieces c hc) (by decide : 0 < 1)]
  congr 1
  rw [degreeOneCoefficient, dehomogenize_linearSection]
  simp only [HomogeneousLocalization.Away.isLocalizationElem, pow_one]

/-- Original conormal generator on its exact Proj nonvanishing locus. -/
lemma degreeOneConormal_isIso_on (c : L) (hc : c ∈ pieces 1) :
    IsIso ((restrictFunctor (Proj.basicOpen (homogeneous pieces) (linearSection pieces c hc)).ι).map
      (degreeOneConormalGenerator c hc)) := by
  apply isIso_restrict_of_local_frames (fun i : Fin 3 => Spec (.of (surfaceChart i)))
    surfaceIota surfaceIota_cover (Proj.basicOpen (homogeneous pieces) (linearSection pieces c hc))
    (degreeOneConormalGenerator c hc)
    (fun i => degreeOneConormalChartSection i (projectiveParameter i) (projectiveParameter_mem i))
    (fun i => (Scheme.ΓSpecIso (.of (surfaceChart i))).inv (degreeOneCoefficient i c hc))
    degreeOneParameterConormal_chart_isIso
  · intro i
    exact degreeOneConormalChartSection_ratio i c hc
  · intro i
    exact le_of_eq (surfaceChart_degreeOne_open i c hc)
end SourcePullbackChart

end

/-! Section ratios are independent of a factorization of an open immersion. -/
noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite
namespace ActualSections
open Scheme.Modules
variable {X Y Z : Scheme.{0}}
lemma scalar_mul (a b : Γ(X,⊤)) : scalar (a*b) = scalar a ≫ scalar b := by
  apply unitHom_ext_top
  change (scalar (a*b)).val.app (op ⊤) (1 : Γ(X,⊤)) =
    (scalar b).val.app (op ⊤) ((scalar a).val.app (op ⊤) (1 : Γ(X,⊤)))
  erw [fromUnit_top, fromUnit_top, fromUnit_top, one_smul, one_smul]
  rfl

lemma restrict_ratio_comp (j : X ⟶ Y) (k : Z ⟶ X)
    [IsOpenImmersion j] [IsOpenImmersion k] {M : Y.Modules}
    (s t : SheafOfModules.unit Y.ringCatSheaf ⟶ M) (a : Γ(X,⊤))
    (hr : (restrictUnitIso j).inv ≫ (restrictFunctor j).map s =
      scalar a ≫ (restrictUnitIso j).inv ≫ (restrictFunctor j).map t) :
    (restrictUnitIso (k ≫ j)).inv ≫ (restrictFunctor (k ≫ j)).map s =
      scalar (k.appTop a) ≫ (restrictUnitIso (k ≫ j)).inv ≫
        (restrictFunctor (k ≫ j)).map t := by
  let e := (restrictUnitIso k).symm ≪≫ (restrictFunctor k).mapIso (restrictUnitIso j).symm
  have he : e.hom ≫ (restrictFunctor j ⋙ restrictFunctor k).map s =
      scalar (k.appTop a) ≫ e.hom ≫ (restrictFunctor j ⋙ restrictFunctor k).map t := by
    exact map_ratio_of_commute (restrictFunctor k) (restrictUnitIso k).inv
      (scalar a) (scalar (k.appTop a)) (restrictUnitIso j).inv
      ((restrictFunctor j).map s) ((restrictFunctor j).map t) hr
      (restrict_scalar_inv k a)
  exact ratio_across_natIso (restrictFunctor (k ≫ j))
    (restrictFunctor j ⋙ restrictFunctor k) (restrictFunctorComp k j) s t
    (restrictUnitIso (k ≫ j)).inv e (k.appTop a) he

lemma restrict_ratio_of_comp (j : X ⟶ Y) (k : Z ⟶ X)
    [IsOpenImmersion j] [IsOpenImmersion k] {M : Y.Modules}
    (s t : SheafOfModules.unit Y.ringCatSheaf ⟶ M) (a : Γ(X,⊤))
    (hr : (restrictUnitIso (k ≫ j)).inv ≫ (restrictFunctor (k ≫ j)).map s =
      scalar (k.appTop a) ≫ (restrictUnitIso (k ≫ j)).inv ≫
        (restrictFunctor (k ≫ j)).map t) :
    (restrictFunctor k).map ((restrictUnitIso j).inv ≫ (restrictFunctor j).map s) =
      (restrictFunctor k).map (scalar a ≫ (restrictUnitIso j).inv ≫ (restrictFunctor j).map t) := by
  let e := (restrictUnitIso k).symm ≪≫ (restrictFunctor k).mapIso (restrictUnitIso j).symm
  have hh := ratio_across_natIso (restrictFunctor j ⋙ restrictFunctor k)
    (restrictFunctor (k ≫ j)) (restrictFunctorComp k j).symm s t e.hom
    (restrictUnitIso (k ≫ j)).symm (k.appTop a) hr
  have : Epi (restrictUnitIso k).inv :=
    @IsIso.epi_of_iso _ _ _ _ _ (restrictUnitIso k).isIso_inv
  apply (cancel_epi (restrictUnitIso k).inv).mp
  erw [Functor.map_comp, Functor.map_comp]
  erw [← Category.assoc (restrictUnitIso k).inv ((restrictFunctor k).map (scalar a)),
    restrict_scalar_inv k a,
    Category.assoc (scalar (k.appTop a)) (restrictUnitIso k).inv]
  exact hh

lemma ratio_of_common_frame {M : X.Modules}
    (s t u : SheafOfModules.unit X.ringCatSheaf ⟶ M) {a b r : Γ(X,⊤)}
    (hs : s = scalar a ≫ u) (ht : t = scalar b ≫ u) (h : a = r*b) :
    s = scalar r ≫ t := by
  erw [hs, h, scalar_mul, Category.assoc, ht]
end ActualSections

end

/-! Homogeneous product charts pull back projective basic-open covers. -/
noncomputable section
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry _root_.HomogeneousLocalization _root_.OAI.HomogeneousLocalization
namespace AlgebraicGeometry.Proj
open scoped _root_.AlgebraicGeometry _root_.AlgebraicGeometry.Proj
variable {σ A : Type} [CommRing A] [SetLike σ A] [AddSubgroupClass σ A]
  (𝒜 : ℕ → σ) [GradedRing 𝒜] {f g : A}
  (hf : f ∈ 𝒜 1) (hg : g ∈ 𝒜 1)
def degreeOneLeft : _root_.AlgebraicGeometry.Spec (.of (Away 𝒜 (f*g))) ⟶ _root_.AlgebraicGeometry.Spec (.of (Away 𝒜 f)) :=
  (_root_.AlgebraicGeometry.Proj.pullbackAwayιIso 𝒜 hf (by decide : 0<1) hg (by decide : 0<1) rfl).inv ≫
    CategoryTheory.Limits.pullback.fst _ _
def degreeOneRight : _root_.AlgebraicGeometry.Spec (.of (Away 𝒜 (f*g))) ⟶ _root_.AlgebraicGeometry.Spec (.of (Away 𝒜 g)) :=
  (_root_.AlgebraicGeometry.Proj.pullbackAwayιIso 𝒜 hf (by decide : 0<1) hg (by decide : 0<1) rfl).inv ≫
    CategoryTheory.Limits.pullback.snd _ _
instance degreeOneLeft_open : _root_.AlgebraicGeometry.IsOpenImmersion (degreeOneLeft 𝒜 hf hg) := by
  unfold degreeOneLeft; infer_instance
instance degreeOneRight_open : _root_.AlgebraicGeometry.IsOpenImmersion (degreeOneRight 𝒜 hf hg) := by
  unfold degreeOneRight; infer_instance
lemma degreeOneLeft_eq : degreeOneLeft 𝒜 hf hg =
    _root_.AlgebraicGeometry.Spec.map (CommRingCat.ofHom (awayMap 𝒜 hg (rfl : f*g=f*g))) :=
  _root_.AlgebraicGeometry.Proj.pullbackAwayιIso_inv_fst 𝒜 hf (by decide : 0<1) hg (by decide : 0<1) rfl
lemma degreeOneRight_eq : degreeOneRight 𝒜 hf hg =
    _root_.AlgebraicGeometry.Spec.map (CommRingCat.ofHom (awayMap 𝒜 hf (mul_comm f g))) :=
  _root_.AlgebraicGeometry.Proj.pullbackAwayιIso_inv_snd 𝒜 hf (by decide : 0<1) hg (by decide : 0<1) rfl
lemma degreeOne_overlap_square :
    degreeOneLeft 𝒜 hf hg ≫ _root_.AlgebraicGeometry.Proj.awayι 𝒜 f hf (by decide : 0<1) =
      degreeOneRight 𝒜 hf hg ≫ _root_.AlgebraicGeometry.Proj.awayι 𝒜 g hg (by decide : 0<1) := by
  simp only [degreeOneLeft, degreeOneRight, Category.assoc, CategoryTheory.Limits.pullback.condition]
lemma degreeOneRight_range : (degreeOneRight 𝒜 hf hg).opensRange =
      _root_.AlgebraicGeometry.Proj.awayι 𝒜 g hg (by decide : 0<1) ⁻¹ᵁ (_root_.AlgebraicGeometry.Proj.awayι 𝒜 f hf (by decide : 0<1)).opensRange := by
  change ((_root_.AlgebraicGeometry.Proj.pullbackAwayιIso 𝒜 hf (by decide : 0<1) hg (by decide : 0<1) rfl).inv ≫
    CategoryTheory.Limits.pullback.snd _ _).opensRange = _
  rw [_root_.AlgebraicGeometry.Scheme.Hom.opensRange_comp_of_isIso, _root_.AlgebraicGeometry.Scheme.Hom.opensRange_pullbackSnd]
lemma degreeOne_intersection_right_cover {I : Type} (f : I → A) (hf : ∀ i, f i ∈ 𝒜 1)
    (hc : (⨆ i, (_root_.AlgebraicGeometry.Proj.awayι 𝒜 (f i) (hf i) (by decide : 0<1)).opensRange) = ⊤) :
    (⨆ i, (degreeOneRight 𝒜 (hf i) hg).opensRange) = ⊤ := by
  simp_rw [degreeOneRight_range]
  rw [← _root_.AlgebraicGeometry.Scheme.Hom.preimage_iSup, hc, _root_.AlgebraicGeometry.Scheme.Hom.preimage_top]
end AlgebraicGeometry.Proj

end

/-! Homogeneous fraction identities on Proj intersections. -/
noncomputable section
namespace HomogeneousLocalization
open scoped _root_.HomogeneousLocalization
open SetLike
variable {σ A : Type*} [CommRing A] [SetLike σ A] [AddSubgroupClass σ A]
  (𝒜 : ℕ → σ) [GradedRing 𝒜]
lemma degreeOne_overlap_ratio {f g c : A}
    (hf : f ∈ 𝒜 1) (hg : g ∈ 𝒜 1) (hc : c ∈ 𝒜 1) :
    _root_.HomogeneousLocalization.awayMap 𝒜 hg (rfl : f*g=f*g) (_root_.HomogeneousLocalization.Away.mk 𝒜 hf 1 c (by simpa using hc)) =
      _root_.HomogeneousLocalization.awayMap 𝒜 hf (mul_comm f g) (_root_.HomogeneousLocalization.Away.mk 𝒜 hg 1 c (by simpa using hc)) *
      _root_.HomogeneousLocalization.awayMap 𝒜 hg (rfl : f*g=f*g) (_root_.HomogeneousLocalization.Away.mk 𝒜 hf 1 g (by simpa using hg)) := by
  apply _root_.HomogeneousLocalization.val_injective
  simp only [_root_.HomogeneousLocalization.val_mul, _root_.HomogeneousLocalization.awayMap_mk, _root_.HomogeneousLocalization.Away.val_mk, pow_one,
    Localization.mk_mul]
  rw [Localization.mk_eq_mk_iff, Localization.r_iff_exists]
  refine ⟨1, ?_⟩
  simp only [Submonoid.coe_one, Submonoid.coe_mul, one_mul]
  ring
end HomogeneousLocalization


/-! Descent of degree-one section ratios along projective basic-open covers. -/
open CategoryTheory _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite _root_.HomogeneousLocalization _root_.OAI.HomogeneousLocalization
namespace ActualSections
open Scheme.Modules
lemma specMap_inv {A B : Type} [CommRing A] [CommRing B] (f : A →+* B) (a : A) :
    (Spec.map (CommRingCat.ofHom f)).appTop ((Scheme.ΓSpecIso (.of A)).inv a) =
      (Scheme.ΓSpecIso (.of B)).inv (f a) :=
  ConcreteCategory.congr_hom (Scheme.ΓSpecIso_inv_naturality (CommRingCat.ofHom f)).symm a
lemma ratio_along_eq {X Y : Scheme.{0}} (j k : X ⟶ Y)
    [IsOpenImmersion j] [IsOpenImmersion k] (h : j = k) {M : Y.Modules}
    (s t : SheafOfModules.unit Y.ringCatSheaf ⟶ M) (a : Γ(X,⊤))
    (hr : (restrictUnitIso j).inv ≫ (restrictFunctor j).map s =
      scalar a ≫ (restrictUnitIso j).inv ≫ (restrictFunctor j).map t) :
    (restrictUnitIso k).inv ≫ (restrictFunctor k).map s =
      scalar a ≫ (restrictUnitIso k).inv ≫ (restrictFunctor k).map t := by
  subst k
  exact hr
end ActualSections
namespace AlgebraicGeometry.Proj
open scoped _root_.AlgebraicGeometry _root_.AlgebraicGeometry.Proj
open Scheme.Modules ActualSections
variable {σ A : Type} [CommRing A] [SetLike σ A] [AddSubgroupClass σ A]
  (𝒜 : ℕ → σ) [GradedRing 𝒜]
/-- A homogeneous degree-one quotient. -/
abbrev degreeOneFraction {f c : A} (hf : f ∈ 𝒜 1) (hc : c ∈ 𝒜 1) : Away 𝒜 f :=
  Away.mk 𝒜 hf 1 c (by simpa using hc)
lemma degreeOne_coefficient_identity {f g c : A}
    (hf : f ∈ 𝒜 1) (hg : g ∈ 𝒜 1) (hc : c ∈ 𝒜 1) :
    (degreeOneLeft 𝒜 hf hg).appTop
        ((_root_.AlgebraicGeometry.Scheme.ΓSpecIso (.of (Away 𝒜 f))).inv (degreeOneFraction 𝒜 hf hc)) =
      (degreeOneRight 𝒜 hf hg).appTop
        ((_root_.AlgebraicGeometry.Scheme.ΓSpecIso (.of (Away 𝒜 g))).inv (degreeOneFraction 𝒜 hg hc)) *
      (degreeOneLeft 𝒜 hf hg).appTop
        ((_root_.AlgebraicGeometry.Scheme.ΓSpecIso (.of (Away 𝒜 f))).inv (degreeOneFraction 𝒜 hf hg)) := by
  rw [degreeOneLeft_eq, degreeOneRight_eq, specMap_inv, specMap_inv, specMap_inv, ← map_mul]
  exact congrArg (_root_.AlgebraicGeometry.Scheme.ΓSpecIso (.of (Away 𝒜 (f*g)))).inv
    (degreeOne_overlap_ratio 𝒜 hf hg hc)

lemma degreeOne_section_ratio {I : Type} (f : I → A) (hf : ∀ i, f i ∈ 𝒜 1)
    (hcover : (⨆ i, (_root_.AlgebraicGeometry.Proj.awayι 𝒜 (f i) (hf i) (by decide : 0<1)).opensRange) = ⊤)
    {g c : A} (hg : g ∈ 𝒜 1) (hc : c ∈ 𝒜 1) {M : (_root_.AlgebraicGeometry.Proj 𝒜).Modules}
    (s t : SheafOfModules.unit (_root_.AlgebraicGeometry.Proj 𝒜).ringCatSheaf ⟶ M)
    (u : I → (SheafOfModules.unit (_root_.AlgebraicGeometry.Proj 𝒜).ringCatSheaf ⟶ M))
    (hs : ∀ i, (restrictUnitIso (_root_.AlgebraicGeometry.Proj.awayι 𝒜 (f i) (hf i) (by decide : 0<1))).inv ≫
        (restrictFunctor (_root_.AlgebraicGeometry.Proj.awayι 𝒜 (f i) (hf i) (by decide : 0<1))).map s =
      scalar ((_root_.AlgebraicGeometry.Scheme.ΓSpecIso (.of (Away 𝒜 (f i)))).inv (degreeOneFraction 𝒜 (hf i) hc)) ≫
        (restrictUnitIso (_root_.AlgebraicGeometry.Proj.awayι 𝒜 (f i) (hf i) (by decide : 0<1))).inv ≫
        (restrictFunctor (_root_.AlgebraicGeometry.Proj.awayι 𝒜 (f i) (hf i) (by decide : 0<1))).map (u i))
    (ht : ∀ i, (restrictUnitIso (_root_.AlgebraicGeometry.Proj.awayι 𝒜 (f i) (hf i) (by decide : 0<1))).inv ≫
        (restrictFunctor (_root_.AlgebraicGeometry.Proj.awayι 𝒜 (f i) (hf i) (by decide : 0<1))).map t =
      scalar ((_root_.AlgebraicGeometry.Scheme.ΓSpecIso (.of (Away 𝒜 (f i)))).inv (degreeOneFraction 𝒜 (hf i) hg)) ≫
        (restrictUnitIso (_root_.AlgebraicGeometry.Proj.awayι 𝒜 (f i) (hf i) (by decide : 0<1))).inv ≫
        (restrictFunctor (_root_.AlgebraicGeometry.Proj.awayι 𝒜 (f i) (hf i) (by decide : 0<1))).map (u i)) :
    (restrictUnitIso (_root_.AlgebraicGeometry.Proj.awayι 𝒜 g hg (by decide : 0<1))).inv ≫
        (restrictFunctor (_root_.AlgebraicGeometry.Proj.awayι 𝒜 g hg (by decide : 0<1))).map s =
      scalar ((_root_.AlgebraicGeometry.Scheme.ΓSpecIso (.of (Away 𝒜 g))).inv (degreeOneFraction 𝒜 hg hc)) ≫
        (restrictUnitIso (_root_.AlgebraicGeometry.Proj.awayι 𝒜 g hg (by decide : 0<1))).inv ≫
        (restrictFunctor (_root_.AlgebraicGeometry.Proj.awayι 𝒜 g hg (by decide : 0<1))).map t := by
  apply CoherentGlobal.hom_ext_of_open_charts
    (fun i => _root_.AlgebraicGeometry.Spec (.of (Away 𝒜 (f i * g)))) (fun i => degreeOneRight 𝒜 (hf i) hg)
    (degreeOne_intersection_right_cover 𝒜 hg f hf hcover)
  intro i
  apply restrict_ratio_of_comp
  apply ratio_along_eq _ _ (degreeOne_overlap_square 𝒜 (hf i) hg)
  exact ratio_of_common_frame _ _ _
    (restrict_ratio_comp _ _ s (u i) _ (hs i))
    (restrict_ratio_comp _ _ t (u i) _ (ht i))
    (degreeOne_coefficient_identity 𝒜 (hf i) hg hc)
end AlgebraicGeometry.Proj

end

end OAI